Maîtriser complètement les classes abstraites et les interfaces en Java-javaDidacticiel-php.cn

Cet article vous apporte des connaissances pertinentes sur java, qui présente principalement des questions connexes sur les classes abstraites et les interfaces, y compris ce qu'est une classe abstraite, la signification du polymorphisme d'implémentation de classe abstraite, etc., examinons-le ensemble, je j'espère que cela sera utile à tout le monde.

Maîtriser complètement les classes abstraites et les interfaces en Java

Apprentissage recommandé : "Tutoriel vidéo Java"

Qu'est-ce qu'une classe abstraite

Nous avons déjà appris ce qu'est une classe, donc une classe abstraite est-elle aussi un type de classe ?

Le nom semble si abstrait ! Vous avez raison, c'est abstrait, pas concret. Une classe qui ne contient pas suffisamment d’informations pour décrire un objet spécifique est appelée classe abstraite.

Regardons un exemple de classe abstraite

// 抽象类和抽象方法需要被 abstract 关键字修饰
abstract class Shape {
    // 抽象类中的方法一般要求都是抽象方法，抽象方法没有方法体
    abstract void draw();
}

Copier après la connexion

Tout le monde pense que cette classe abstraite ne fait rien, et sa seule méthode draw() est toujours vide.

Une classe comme celle-ci ne contient-elle pas suffisamment d'informations pour décrire un objet spécifique ? Naturellement, l'objet ne peut pas être instancié. Si vous ne me croyez pas, jetez un oeil :

Alors puisqu'une classe ne peut pas être instanciée, quel est le sens de l'existence de cette classe abstraite ?

L'importance des classes abstraites dans la réalisation du polymorphisme

L'une des plus grandes significations de l'existence des classes abstraites est d'être héritées. Après avoir été héritées, les classes abstraites peuvent être utilisées pour implémenter le polymorphisme.

Jetons un œil à un morceau de code

// 抽象类和抽象方法需要被 abstract 关键字修饰
abstract class Shape {
    // 抽象类中的方法一般要求都是抽象方法，抽象方法没有方法体
    abstract void draw();
}
// 当一个普通类继承一个抽象类后，这个普通类必须重写抽象类中的方法
class Cycle extends Shape {
    @Override
    void draw() {  // 重写抽象类中的draw方法
        System.out.println("画一个圆圈");
    }
}

public class Test4 {
    public static void main(String[] args) {
        //Shape shape = new Shape();  抽象类虽然不能直接实例化
        // 但可以把一个普通类对象传给一个抽象类的引用呀，即父类引用指向子类对象
        Shape shape = new Cycle(); // 这称作：向上转型
        
        /*Cycle cycle = new Cycle();
          Shape shape = cycle // 这是向上转型的另一种写法
         */
        shape.draw();         // 通过父类引用调用被子类重写的方法
    }
}

Copier après la connexion

Après l'avoir exécuté, vous découvrirez une scène magique :

Vous aurez peut-être beaucoup de questions après avoir lu le code, ne vous inquiétez pas, parlons-en un par un,

Qu'est-ce que c'est une transformation vers le haut : en une phrase, "la référence de la classe parent pointe vers l'objet de la classe enfant"

Les changements après transformation vers le haut

À propos de la méthode : la référence de la classe parent peutappeler les méthodes communes à la sous-classe et à la classe parent( Si la sous-classe remplace la méthode de la classe parent, la méthode de la sous-classe est appelée), mais les méthodes propres à la sous-classe ne peuvent pas être appelé.
À propos des attributs : les références de classe parent peuvent appeler les attributs de la classe parent, mais pas les attributs de la sous-classe

Le rôle de la transformation ascendante

Réduire certains codes répétitifs
Object instances Lors de l'instanciation, différents objets peuvent être instanciés en fonction de différents besoins

De cette façon, notre code ci-dessus peut être compris

Il semble que nous puissions hériter et réutiliser des classes abstraites à travers des sous-classes Écriture, résumé les cours sont vraiment utiles !

Mais qu'est-ce que cela a à voir avec le polymorphisme ? Les classes abstraites sont si difficiles à utiliser. Je pourrais aussi bien utiliser des classes ordinaires pour obtenir le même effet sans avoir à écrire une sous-classe ?

Cette ligne, si vous regardez le code ci-dessous, vous connaîtrez les avantages des classes abstraites dans l'implémentation du polymorphisme.

abstract class Shape {
    public abstract void draw(); // 抽象方法不能里有具体的语句
}
// 当一个普通类继承一个抽象类的时候，再这个子类中必须重写抽象类中的抽象方法
class Cycle extends Shape {  
    @Override              // 如果不重写会报错，但如果继承的是普通类则不会报错，用抽象类更安全
    public void draw() {
        System.out.println("画一个圆圈");
    }
}
class Flower extends Shape { // 不同的子类对父类的draw方法进行了不同的重写
    @Override
    public void draw() {
        System.out.println("画一朵花");
    }
}
class Square extends Shape {
    @Override
    public void draw() {
        System.out.println("画一个正方形");
    }
}

public class Test4 {
    public static void main(String[] args) {
        Cycle cycle = new Cycle();   // 子类引用cycle
        Flower flower = new Flower(); // 子类引用flower
        Square square = new Square();
        
        // 数组的类型是Shape,即数组中每一个元素都是一个父类引用
        // 在这个过程其实也发生了向上转型，对抽象类中的方法进行了重写
        Shape[] shapes = {cycle, flower, square};  // 父类引用引用不同的子类对象
        for (int i = 0; i < shapes.length; i++) {
            Shape shape = shapes[i]; // 父类引用shape指向—>当前所对应的子类对象

            shape.draw();  // 通过父类引用调用子类重写的draw方法
        }

    }
}

Copier après la connexion

L'appel de la même méthode affiche en fait des résultats différents. Est-ce ce qu'on appelle le polymorphisme ? la classe abstraite Shape)

Réécriture (la réécriture de la méthode draw par notre sous-classe)

Classe Parent Pointez sur l'objet de la sous-classe (c'est-à-dire shape1[0] = cycle --> peut également être appelé transformation ascendante )

Regardez notre code pour voir s'il répond simplement aux trois éléments du polymorphisme.
Lorsque la référence de notre classe parent pointe vers différents objets de sous-classe, différents résultats sont générés lorsque nous appelons la même méthode draw. (En fait, cette méthode est réécrite sous différentes formes dans les sous-classes.) C'est ce qu'on appelle le polymorphisme.
Alors pourquoi faut-il utiliser des classes abstraites ? N'est-il pas possible pour une classe normale d'hériter d'une classe normale pour atteindre le polymorphisme

Bien sûr, c'est possible, mais ce n'est ni sûr ni risqué ;

但如果是抽象类的话，就不一样了

从这我们也可以看出，当用抽象类的时候，编译器自动就对我们是否重写进行了校验，而充分利用编译器的校验, 在实际开发中是非常有意义的。所以说抽象类还是有用的

好了，相信到这里你对抽象类也有了一个大概的认识，下面来简单做一下总结

使用abstract修饰的类或方法，就抽象类或者抽象方法
抽象类是不能具体的描述一个对象，不能用抽象类直接实例化对象
抽象类里面的成员变量和成员方法，都是和普通类一样的，只不过就是不能进行实例化了
当一个普通类继承这个抽象类后，那么这个普通类必须重写抽象类当中的所有的抽象方法（我们之前说过抽象类是不具体的，没有包含足够的信息来描述一个对象，所以我们需要把他补充完整）
但当一个抽象类A继承了抽象类B，这是抽象类A就可以不重写抽象类B当中的抽象方法
final不能修饰抽象类和抽象方法（因为抽象类存在的最大意义就是被继承，而被final修饰的不能被继承，final和抽象，他们两个是天敌）
抽象方法不能被private修饰（抽象方法一般都是要被重写的，你被private修饰了，还怎么重写）
抽象类当中不一定有抽象方法，但如果一个类中有抽象方法，那么这个类一定是抽象类。

接口是什么

抽象类是从多个类中抽象出来的模板，如果将这种抽象进行的更彻底，则可以提炼出一种更加特殊的“抽象类”——接口（Interface）。

接口是Java中最重要的概念之一，它可以被理解为一种特殊的类，不同的是接口的成员没有执行体，是由全局常量和公共的抽象方法所组成。

如何定义一个接口呢？下面我们来看一个栗子

//接口的定义格式与定义类的格式基本相同，将class关键字换成 interface 关键字，就定义了一个接口

public interface 接口名称{
// 定义变量
int a = 10;      // 接口当中的成员变量默认都是public static final

// 抽象方法
public abstract void method1(); // public abstract 是固定搭配，可以不写
void method2();  //  接口当中的成员方法默认都是public abstract, 更推荐用第二种来定义方法 
}

Copier après la connexion

可以看到接口和类其实还是有很多相似点：

接口中也包含抽象方法，所以也不能直接实例化接口，那么我们怎么用接口呢？

哈哈，很简单，我们再用一个普通类实现这个接口不就行了吗，不同的是抽象类是被子类来继承而实现的，而接口与类之间则是用关键字implements来实现。

就像普通类实现实现抽象类一样，一个类实现某个接口则必须实现该接口中的抽象方法，否则该类必须被定义为抽象类。

通过接口实现多态

铁汁们！刚才我们是用抽象类来实现多态，那么现在我们可以尝试用接口来实现多态，

接口可以看成是一种特殊的类，只能用 interface 关键字修饰
interface IShape {
    int a = 10;   接口当中的成员变量默认都是public static final
    int b = 23;
    void draw();  接口当中的成员方法一般只能是抽象方法，默认是public abstract（JDK1.8以前）
  
    default void show() {
        System.out.println("接口中的其他方法");//接口中的其他方法也可以实现，但要用default修饰
    }
    public static void test() {
        System.out.println("这是接口当中的一个静态的方法");
    }
}

// 一个普通的类要想实现接口，可以用implement, 
//因为接口也是抽象方法的，所以实现接口的这个类也要重写抽象方法
class Cycle implements IShape {

    @Override
    public void draw() {
        System.out.println("画一个圆圈");
    }
}
class Square implements IShape {
    @Override
    public void draw() {
        System.out.println("画一个正方形");
    }
}
class Flower implements IShape {

    @Override
    public void draw() {
        System.out.println("画一朵花");
    }
}
public class Test4 {
    public static void main(String[] args) {
        // IShape iShape = new IShape(); 接口也不能直接实例化
        Cycle cycle = new Cycle();
        Square square = new Square();
        Flower flower = new Flower();
        // 这里的IShape接口就相当与抽象类中父类，接口类型也是一种引用类型

        IShape[] iShapes = {cycle, square, flower}; // 这个过程其实就发生了向上转型

        for (IShape iShape : iShapes) { // 增强型的for—each循环，也可以写成普通的for循环形式
            iShape.draw();              // 通过重写实现了多态
        }
    }
}
引用变量cycle和square都赋值给了Shape类型的引用变量shape,
但当执行shape.draw()时，java虚拟机到底要调用谁重写的的draw方法，
就看此时接口引用的是那个对象的，是shape的、还是cycle的

Copier après la connexion

看一下运行结果

看完代码你可能有点晕，但没关系。一般接口咱也不这么用，直接使用抽象类不就好了（我只是演示一下用接口也能实现多态）

下面我们来总结一下Java中接口的几个主要特点

接口中可以包含变量和方法，变量被隐式指定为 public static final，方法被隐式指定为 public abstract（JDK 1.8 d一个类可以同时实现多个接口，一个类实现某个接口则必须实现该接口中的抽象方法，否则该类必须被定义为抽象类
接口支持多继承，即一个接口可以继承（extends）多个接口，间接解决了 Java 中类不能多继承的问题。

那么接口一般用在什么地方呢？

一般情况下，实现类和它的抽象类之前具有 "is-a" 的关系，但是如果我们想达到同样的目的，但是又不存在这种关系时，使用接口。
由于 Java 中单继承的特性，导致一个类只能继承一个类，但是可以实现一个或多个接口，此时可以使用接口。

下面就让我们来看看接口的正确用法：帮助java实现“ 多继承 ”

由于 Java 中单继承的特性，导致一个类只能继承一个类，但是可以实现一个或多个接口，此时可以使用接口。
class Animal {
    String name;        // 不能使用private,后面的子类也要用

    public Animal(String name) { // 父类的自定义的构造方法
        this.name = name;
    }
}
interface IFlying {   // 自定义多种接口
    void fly();
}
interface IRunning {
    void run();
}
interface ISwimming {
    void swimming();
}
// 小鸭子，不仅会跑，还会游泳、飞行
一个类继承父类，并实现多个接口，间接的解决java中不能多继承的问题
class Duck extends Animal implements IRunning, ISwimming, IFlying {

    public Duck(String name) {  // 子类构造方法
        super(name);            // 必须在子类构造方法的第一行
        // 在给实现子类的构造方法前，先要用super()调用实现父类的构造方法，比较先有父后有子呀！
        // 因为父类自己定义了构造方法，编译器不会自动给给子类构造方法中添加super();来实现父类的构造方法，需要我们自己实现
    }
    // 对接口中的抽象方法进行重写
    @Override
    public void fly() {
        System.out.println(this.name + "正在用翅膀飞");
    }

    @Override
    public void run() {
        System.out.println(this.name + "正在用两条腿跑");
    }

    @Override
    public void swimming() {
        System.out.println(this.name + "正在漂在水上");
    }

}

public class 接口的使用 {  // 不用学我用中文名作为类名，我只是为演示方便
    public static void main(String[] args) {
        Duck duck = new Duck("第一个小鸭子");  // 实例化鸭子对象
        duck.fly();  // 通过引用 变量名.方法名 输出重写后的方法
        duck.run();
        duck.swimming();
    }
}
有人可能会说干嘛用接口，我直接在父类Animal中实现fly、run、swimming这些属性，
然后不同的动物子类再继承父类这些方法不行吗？

但问题是，鸭子会fly、swimming，那猫会飞和游泳吗？你再写个其他动物的子类是不是就不行了
而用接口呢？我们只是把这种飞、游泳的行为给抽象出来了，

只要一个子类有这种行为，他就可以实现相对应的接口，接口是更加灵活的

Copier après la connexion

上面的代码展示了 Java 面向对象编程中最常见的用法: 一个类继承一个父类, 同时实现多个接口。

继承表达的含义是 is - a 语义, 而接口表达的含义是具有 xxx 特性，能实现接口的类和该接口并不一定有is_a的关系，只要该类有这个接口的特性就行

猫是一种动物, 具有会跑的特性.

青蛙也是一种动物, 既能跑, 也能游泳

鸭子也是一种动物, 既能跑, 也能游, 还能飞

这样设计有什么好处呢? 时刻牢记多态的好处, 让程序猿忘记类型. 有了接口之后, 类的使用者就不必关注具体类型，只要这个类有有这个特性就好。

举个栗子

class Robot implements IRunning {
    private String name;
    public Robot(String name) {
        this.name = name;
    }
    // 对run方法进行重写
    @Override
    public void run() {
        System.out.println("机器人" + this.name + "正在跑");
    }
}
public class Test4 {
    public static void main(String[] args) {
        Robot robot1 = new Robot("图图");
        robot1.run();
    }
}
// 执行结果
机器人图图正在跑

Copier après la connexion

只要能跑就行，管他是机器人还是动物呢

推荐学习：《java视频教程》

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!