Java >> Tutoriel Java >  >> Tag >> class

Classe abstraite Java | Exemples, constructeur, méthode par défaut

class

Qu'est-ce qu'une classe abstraite en Java ?

Une classe Java est déclarée avec un mot-clé abstrait appelé "Java Abstract Class “. Une classe abstraite peut avoir des méthodes abstraites et aucune méthode abstraite ou les deux. Cette classe ne peut pas être instanciée, elle doit être étendue et sa méthode implémentée.

A point de la classe abstraite Java

Abstraction est l'une des principales caractéristiques du concept de POO. Abstraction est un processus de masquage des détails de mise en œuvre et de gestion de la complexité de l'utilisateur, seule fonctionnalité principale et utilisable fournie à l'utilisateur.

Par exemple , Une voiture n'a que l'option principale donnée à l'utilisateur pour la contrôler. Comme la pause, la vitesse, la direction, l'accélérateur, etc. Pas tous les détails sur le fonctionnement interne.

Voyons les points à retenir :-

  • Cours abstraits doit être déclaré avec un mot-clé abstrait.
  • Classe abstraite Java ne peut pas être instancié.
  • Pour utiliser une classe abstraite en Java, vous devez l'hériter d'une autre classe et y implémenter les méthodes abstraites.
  • A hérite d'une classe abstraite, doit fournir des implémentations à toutes les méthodes abstraites qu'elle contient.
  • Cours abstraits peut contenir ou non des méthodes abstraites (méthodes normales).
  • Si une classe a une méthode abstraite (sans corps) doit être déclarée avec un mot-clé abstrait.
  • Peut avoir des constructeurs, des méthodes statiques et des méthodes finales.

Syntaxe

Une syntaxe simple pour déclarer une classe abstraite.

abstract class ClassName{ }

Méthode abstraite la syntaxe est :-

abstract void MethodName();

Code d'exemple de classe abstraite Java

Voyons un exemple, où un nom de classe abstrait "ObjectSahpe" et avoir une méthode abstraite (sans méthode de corps) avec le nom "draw()"

Une classe de forme est d'avoir la méthode principale pour accéder à ce programme. C'est un exemple très simple et basique d'abstraction en Java.

package a.b;

abstract class ObjectShapes {
    abstract void draw();
}

class Rectangle extends ObjectShapes{

    @Override
    void draw() {
        System.out.println("Draw Rectangle");
    }
}

class Shape{
    public static void main(String args[]){
        ObjectShapes rect1=new Rectangle();
        rect1.draw();
    }
}

Sortie : Dessiner un rectangle

Méthodes abstraites

Une méthode abstraite n'a pas de corps, seulement un nom de méthode et " E ND ” avec des points-virgules.

public abstract void sleep();

Cette méthode doit être remplacée pour être utilisée.

Remarque : Vous ne pouvez pas avoir de méthode abstraite dans une classe non abstraite. Et vous devez implémenter toutes les méthodes abstraites.

Constructeur de classe abstrait Java | Membre de données | Plus de méthodes

Une classe abstraite peut avoir :

  • Méthode abstraite
  • Méthode non abstraite (corps de la méthode)
  • Constructeur
  • Membre de données
  • Méthode Java main().

Voyons l'exemple des membres de données et des méthodes de cantering de classe.

Animal.java 

abstract class Animal {

    // declare data member
    String objectName = " ";

    //constructor
    Animal(String name) {
        objectName = name;
        System.out.print(name + "Animal created ");
    }

    //constructor
    Animal() {
        System.out.println("Animal created ");
    }

    // normal method
    public void sleep() {
        System.out.println("Animal sleeping time");
    }

    // normal method
    public void eat() {
        System.out.println("Animal eat something");
    }

    // Abstract method
    public abstract void makeNoise();
}

class Dog extends Animal {

    Dog (String name){
        super(name);
    }
    public void makeNoise() {
        System.out.println("Bark! Bark!");
    }
}

class Cow extends Animal {
    Cow (String name){
        super(name);
    }
    public void makeNoise() {
        System.out.println("Moo! Moo!");
    }

}

AbstractionEx.java 

public class AbstractionEx {
    public static void main(String args[]){
        //cow object
        Cow cow = new Cow("Cow ");
        cow.makeNoise();
        cow.sleep();
        cow.eat();

        //Dog object
        Dog dog = new Dog("Dog ");
        dog.makeNoise();
        dog.sleep();
        dog.eat();
    }
}

Sortie :

Comment implémenter l'interface de classe abstraite Java ?

Réponse : Une classe ne peut hériter que d'une seule classe mais peut implémenter plusieurs interfaces en Java.

Une classe abstraite est très similaire à une interface. La principale différence est qu'une classe abstraite peut déjà définir certaines fonctions, une interface ne le peut pas (notez que cela a changé dans Java9+).

Maintenant, pour répondre, vous devez utiliser un mot-clé "implémenter" pour implémenter l'interface.

interface :– Marche 

package abs.intr;

interface Walk {
    String walk();
}

Classe abstraite :- Interface Walk implémentée par des animaux 

package abs.intr;

abstract class Animal implements Walk {
    public abstract String MakeNoise();
}

Le principal classe pour l'exécution de code :- avec les méthodes concrètes du chat et du chien.

package abs.intr;

public class MainClass {

    public static void main(String args[]){
        Animal catObj = new Cat();
        System.out.println(catObj.MakeNoise());

        Animal dogObj = new Dog();
        System.out.println(dogObj.MakeNoise());
    }
}

class Cat extends Animal {
    public String MakeNoise() {
        return "Meow";
    }

    @Override
    public String walk() {
        return "cat is walking";
    }
}

class Dog extends Animal {
    @Override
    public String walk() {
        return "Dog is walking";
    }

    @Override
    public String MakeNoise() {
        return "bark";
    }
}

Sortie : Miaou
écorce

Remarque : Les méthodes d'interface sont toutes publiques par défaut, même si le public mot clé n'est pas présent (utilisé). Les classes qui implémentent l'interface doivent rendre publiques toutes leurs méthodes implémentées, et le public mot clé doit être présent.

Q : Quel est le but de la classe Abstract en Java ?

Réponse : La classe principalement abstraite est utilisée pour réaliser une abstraction. Ces classes sont utilisées pour fournir des fonctionnalités communes à travers un ensemble de classes connexes tout en permettant également des implémentations de méthodes par défaut.

Remarque : Cet exemple (Project) est développé dans IntelliJ IDEA 2018.2.6 (Community Edition)
JRE :11.0.1
JVM :VM serveur OpenJDK 64 bits par JetBrains s.r.o
mac OS 10.14.1
Java version 11
Toutes les classes abstraites dans les exemples Java sont en Java 11, il peut donc changer selon Java 9 ou 10 ou les versions mises à niveau.


Balise Java