Beherrschen Sie abstrakte Klassen und Schnittstellen in Java vollständig-javaLernprogramm-php.cn

Dieser Artikel vermittelt Ihnen relevantes Wissen über Java, in dem hauptsächlich verwandte Fragen zu abstrakten Klassen und Schnittstellen vorgestellt werden, einschließlich der Frage, was eine abstrakte Klasse ist, der Bedeutung des Implementierungspolymorphismus abstrakter Klassen usw. Schauen wir uns das gemeinsam an, I Ich hoffe, es wird für alle hilfreich sein.

Beherrschen Sie abstrakte Klassen und Schnittstellen in Java vollständig

Empfohlenes Lernen: „Java-Video-Tutorial“

Was ist eine abstrakte Klasse?

Wir haben bereits gelernt, was eine Klasse ist. Ist eine abstrakte Klasse also auch eine Art Klasse?

Der Name klingt so abstrakt! Sie haben Recht, es ist abstrakt, nicht konkret. Eine Klasse, die nicht genügend Informationen zur Beschreibung eines bestimmten Objekts enthält, wird als abstrakte Klasse bezeichnet.

Schauen wir uns ein Beispiel einer abstrakten Klasse an

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

Nach dem Login kopieren

Jeder denkt, dass diese abstrakte Klasse nichts tut und ihre einzige Methode draw() noch leer ist.

Enthält eine solche Klasse nicht genügend Informationen, um ein bestimmtes Objekt zu beschreiben? Natürlich kann das Objekt nicht instanziiert werden. Wenn Sie mir nicht glauben, werfen Sie einen Blick darauf:

Da eine Klasse also nicht instanziiert werden kann, was bedeutet die Existenz dieser abstrakten Klasse?

Die Bedeutung abstrakter Klassen bei der Realisierung von Polymorphismus

Eine der größten Bedeutungen der Existenz abstrakter Klassen ist die Vererbung. Bei der Vererbung können abstrakte Klassen zur Implementierung von Polymorphismus verwendet werden. Schauen wir uns einen Code an es nacheinander,

Was ist eine Aufwärtstransformation: In einem Satz „zeigt die übergeordnete Klassenreferenz auf das untergeordnete Klassenobjekt“

Die Änderungen nach der Aufwärtstransformation

Über die Methode: Die übergeordnete Klassenreferenz kann die öffentlichen Methoden der Unterklasse und der übergeordneten Klasse aufrufen (

Wenn die Unterklasse die Methode der übergeordneten Klasse überschreibt, wird die Methode der Unterklasse aufgerufen), die für die Unterklasse eindeutigen Methoden jedoch nicht angerufen.

Über Attribute: Übergeordnete Klassenreferenzen können die Attribute der übergeordneten Klasse aufrufen, jedoch nicht die Attribute der Unterklasse.

Die Rolle der Aufwärtstransformation. Reduzieren Sie einige sich wiederholende Codes. Objekt Instanzen Beim Instanziieren können verschiedene Objekte je nach Bedarf instanziiert werdenAuf diese Weise kann unser obiger Code verstanden werden

Es scheint, dass wir abstrakte Klassen über Unterklassen erben und wiederverwenden können Schreiben, abstrakt Kurse sind wirklich nützlich!

// 抽象类和抽象方法需要被 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(); // 通过父类引用调用被子类重写的方法 } }
Nach dem Login kopieren

Die gleiche Methode aufrufen und unterschiedliche Ergebnisse ausdrucken. Ist dies der sogenannte Polymorphismus? In Bezug auf den Zustand hat er diese drei Elemente

Vererbung (die Zyklusklasse, die wir gerade geerbt haben). erbt die abstrakte Klasse Shape)

Rewriting (das Umschreiben der Zeichenmethode durch unsere Unterklasse)

Elternklasse Zeigen Sie auf das Unterklassenobjekt (dh shape1[0] = Cycle --> kann auch nach oben aufgerufen werden Transformation)

Schauen Sie sich noch einmal unseren Code an, um zu sehen, ob er nur die drei Elemente des Polymorphismus erfüllt.

Wenn unsere übergeordnete Klasse auf verschiedene Unterklassenobjekte verweist, werden unterschiedliche Ergebnisse ausgegeben, wenn wir dieselbe Zeichenmethode aufrufen. (Tatsächlich wird diese Methode in Unterklassen in verschiedene Formen umgeschrieben.) Dies wird als Polymorphismus bezeichnet.

Hehe, in der Tat ist Polymorphismus nicht so schwer zu verstehen, solange man es anhand von Beispielen betrachtet.

Warum müssen Sie dann abstrakte Klassen verwenden? Ist es für eine normale Klasse nicht möglich, von einer normalen Klasse zu erben, um Polymorphismus zu erreichen? Natürlich ist es möglich, aber es ist weder sicher noch riskant

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

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

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

使用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, 更推荐用第二种来定义方法 
}

Nach dem Login kopieren

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

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

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

Nach dem Login kopieren

看一下运行结果

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

下面我们来总结一下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，那猫会飞和游泳吗？你再写个其他动物的子类是不是就不行了
而用接口呢？我们只是把这种飞、游泳的行为给抽象出来了，

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

Nach dem Login kopieren

上面的代码展示了 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();
    }
}
// 执行结果
机器人图图正在跑

Nach dem Login kopieren

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

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

Das obige ist der detaillierte Inhalt vonBeherrschen Sie abstrakte Klassen und Schnittstellen in Java vollständig. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!