Exemple d'analyse de la définition abstraite Java

1. Présentation

Dans le concept de POO, tous les objets sont décrits à travers des classes mais toutes les classes ne sont pas utilisées pour décrire des objets. Si une classe ne contient pas suffisamment d’informations pour décrire un objet concret, une telle classe est appelée classe abstraite.

Classe abstraite : (1) La classe abstraite ne peut pas instancier des objets. Si un objet est instancié, la compilation ne réussira pas. Seules les sous-classes non abstraites des classes abstraites peuvent créer des objets (2) pouvant inclure : des variables membres, des méthodes membres, des constructeurs, etc. (3) Les constructeurs et les méthodes de classe (méthodes modifiées avec static) ne peuvent pas être déclarés comme méthodes abstraites

Méthodes abstraites : (1) Si une classe contient des méthodes abstraites, alors la classe doit être une classe abstraite (2) Toute sous-classe doit répéter Write une méthode abstraite de la classe parent, ou déclarez-vous comme classe abstraite

Définition : classe abstraite nom de classe

2 Exemple : Les agriculteurs nourrissent les animaux

Animal : classe abstraite--------getName(), move(), drink()

Reptile, Mammifère : hérite de la classe abstraite

Serpent, tigre, chèvre, lapin : hérite respectivement de Reptile ou de Mammifère

fammer: bringWater(), feedWater(Animal animal)---- Responsable pour apporter de l'eau Allez à l'endroit désigné, puis l'animal se déplace vers la destination et boit de l'eau

Le code est le suivant :

package abstractDemo;
 
/**
 * @author lpx
 * @Description TODO
 * @date 2021-04-07
 */
public abstract class Animal {
    abstract String getName();
    abstract void move(String destination);
    abstract void drink();
}
abstract class Reptile extends Animal{
 
}
 
abstract class Mammal extends Animal{
 
}
 
class Tiger extends Mammal{
    private static String name="tiger";
 
    @Override
    String getName() {
        return this.name;
    }
 
    @Override
    void move(String destination) {
        System.out.println("tiger move to "+destination+".");
    }
 
    @Override
    void drink() {
        System.out.println("tiger lower it is head and drink");
    }
}
 
class Goat extends Mammal{
    private static String name="goat";
 
    @Override
    String getName() {
        return this.name;
    }
 
    @Override
    void move(String destination) {
        System.out.println("goat move to "+destination+".");
    }
 
    @Override
    void drink() {
        System.out.println("goat lower it head to drink");
    }
}
 
class Rabbit extends Mammal{
    private static String name="rabbit";
 
    @Override
    String getName() {
        return this.name;
    }
 
    @Override
    void move(String destination) {
        System.out.println("rabbit move to "+destination+".");
    }
 
    @Override
    void drink() {
        System.out.println("rabbit put out it is tongue and drink");
    }
}
 
class Snake extends Reptile{
    private static String name="snake";
 
    @Override
    String getName() {
        return this.name;
    }
 
    @Override
    void move(String destination) {
        System.out.println("snake move to "+destination+".");
    }
 
    @Override
    void drink() {
        System.out.println("snake dived into and drink");
    }
}
 
class Farmer{
    public void bringWater(String destination){
        System.out.println("Farmer bring water to " + destination + ".");
    }
 
    public void feedWater(Animal a){ // polymorphism
        this.bringWater("Feeding Room");
        a.move("Feeding Room");
        a.drink();
    }
 
}
 
class Test{
    public static void main(String[] args) {
        Farmer fm=new Farmer();
        Snake snake=new Snake();
        Goat goat=new Goat();
        Tiger tiger=new Tiger();
        Rabbit rabbit=new Rabbit();
 
        fm.feedWater(snake);
        fm.feedWater(goat);
        fm.feedWater(tiger);
        fm.feedWater(rabbit);
    }
}

Résultat de l'exécution :

Résumé :

Si chaque animal le fait Si nous ne faisons pas abstraction des méthodes de boisson et de déplacement, le polymorphisme ne peut pas être atteint. La classe d'agriculteurs doit surcharger plusieurs feedWaters en fonction de différents paramètres. Si vous continuez à ajouter des animaux, le nombre de rechargements augmentera. Afin de faciliter la comparaison et la compréhension, je l'ai également écrit selon la pensée conventionnelle. Le code est le suivant :

package abstractDemo;
 
/**
 * @author lpx
 * @Description TODO
 * @date 2021-04-07
 */
 
class Tiger1{
    private static String name="tiger";
 
    String getName() {
        return this.name;
    }
 
    void move(String destination) {
        System.out.println("tiger move to "+destination+".");
    }
 
    void drink() {
        System.out.println("tiger lower it is head and drink");
    }
}
 
class Goat1{
    private static String name="goat";
 
    String getName() {
        return this.name;
    }
 
    void move(String destination) {
        System.out.println("goat move to "+destination+".");
    }
 
    void drink() {
        System.out.println("goat lower it head to drink");
    }
}
 
class Rabbit1{
    private static String name="rabbit";
 
    String getName() {
        return this.name;
    }
 
    void move(String destination) {
        System.out.println("rabbit move to "+destination+".");
    }
 
    void drink() {
        System.out.println("rabbit put out it is tongue and drink");
    }
}
 
class Farmer1{
    public void bringWater(String destination){
        System.out.println("Farmer bring water to " + destination + ".");
    }
 
    public void feedWater(Goat1 goat){ // polymorphism
        this.bringWater("Feeding Room");
        goat.move("Feeding Room");
        goat.drink();
    }
    public void feedWater(Tiger1 tiger){ // polymorphism
        this.bringWater("Feeding Room");
        tiger.move("Feeding Room");
        tiger.drink();
    }
 
    public void feedWater(Rabbit1 rabbit1) {
        this.bringWater("Feeding Room");
        rabbit1.move("Feeding Room");
        rabbit1.drink();
    }
}
 
public class Test1{
    public static void main(String[] args) {
        Farmer1 farmer1=new Farmer1();
        Tiger1 tiger1=new Tiger1();
        Goat1 goat1=new Goat1();
        Rabbit1 rabbit1=new Rabbit1();
        farmer1.feedWater(tiger1);
        farmer1.feedWater(goat1);
        farmer1.feedWater(rabbit1);
    }
}

J'ai tapé cet exemple à la main et j'ai découvert que les bases n'étaient pas très importantes dans le passé. , ce qui a semé la confusion à de nombreux endroits et je ne savais pas pourquoi je l'avais écrit ainsi.

(1) Plusieurs classes peuvent être définies dans un fichier .java, mais une seule peut être définie comme publique, et le nom de la classe doit être le même que le nom du fichier

(2) Les classes abstraites héritent des classes abstraites sans remplacer leurs méthodes abstraites (la raison est également très simple. Elle est abstraite et ne peut pas implémenter le corps de la méthode). Alors que les classes non abstraites héritent, les classes abstraites doivent remplacer les méthodes abstraites, et les méthodes non abstraites ne sont pas nécessaires.

(3) La différence entre réécriture et surcharge (question d'entretien très fréquente ?)

Surcharge : définissez le même nom de méthode mais des paramètres différents. Il appartient au polymorphisme à la compilation

Réécriture : la sous-classe remplace la méthode @Override de la classe parent. Appartient au polymorphisme d'exécution

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!