Vertieftes Verständnis abstrakter Klassen und Schnittstellen in Java

Ich glaube, jeder hat das Gefühl: Es gibt zu viele Ähnlichkeiten und zu viele Unterschiede zwischen abstrakten Klassen und Schnittstellen. Diese beiden verwirren Anfänger oft. Ob in der tatsächlichen Programmierung oder in Interviews, abstrakte Klassen und Schnittstellen sind besonders wichtig! Ich hoffe, dass nach dem Lesen dieses Artikels jeder die beiden ruhig verstehen kann...

Abstrakte Klasse, wie ich sie verstehe

1. Abstrakte Klassen haben den gleichen Geschmack wie Klassen

1) Abstrakte Klassen können genauso wie Klassen verwendet werden
2), abstrakte Klassen können alle Komponenten haben, die eine Klasse haben kann [einschließlich Konstruktoren, statische statische Modifikationskomponenten usw.]

Abstrakte Klassen sind genau so, wie der Name sie definiert, sie sind auch A-Klasse

2. Abstrakte Methode

Man muss es gut wissen, bevor man über verschiedene Reize spricht Abstrakte Methode ：

1), abstrakte Methode hat keinen Methodenkörper
2), abstrakte Methode muss mit dem Schlüsselwort abstract geändert werden
3), Klasse mit abstrakter Methode muss Es handelt sich um eine abstrakte Klasse
4). Die abstrakte Methode muss public oder protected sein. Standardmäßig ist public

angegeben Methoden

3. Der seltsame Charme abstrakter Klassen und Klassen

1), abstrakte Klassen müssen mit dem Schlüsselwort abstract geändert werden und Klassen mit abstrakten Modifikationen Es ist eine abstrakte Klasse!
2), abstrakte Klassen können abstrakte Methoden haben oder auch nicht
3), obwohl abstrakte Klassen Konstruktoren haben, können sie nicht zum direkten Erstellen von Objektinstanzen verwendet werden
4), abstrakte Klassen können nicht verwendet werden final , privateÄnderung
5) Externe abstrakte Klassen können nicht mit Static geändert werden, interne abstrakte Klassen können jedoch mit Static deklariert werden. Der Code zum Verständnis dieses Satzes lautet wie folgt:

rrree

Manche Kinderschuhe sind so verwirrend C extends A.BWas ist das für eine coole Operation? Ja, wenn die mit static deklarierte interne abstrakte Klasse einer externen abstrakten Klasse entspricht, wird der Klassenname beim Erben in der Form „externe Klasse. interne Klasse“ ausgedrückt. Diese Art von coolem Betrieb ist wirklich sicher und dünn.

Abstrakte Klasse ist eine besondere Klasse. Es gibt einen wesentlichen Unterschied zwischen abstrakter Klasse und gewöhnlicher Klasse

4 Abstrakte Klassen existieren zum Zweck der Vererbung. Wenn Sie eine abstrakte Klasse definieren, sie aber nicht erben, ist die erstellte abstrakte Klasse bedeutungslos!

Obwohl abstrakte Klassen Konstruktoren haben, können sie es nicht sein Direkt instanziiert

, erfordert das Erstellen eines Objekts eine Aufwärtstransformation, hauptsächlich für den Aufruf durch seine Unterklassen Es gibt auch den Satz, dass abstrakte Klassen keine abstrakten Methoden haben können, das ist nur ein wichtiges Konzept, an das man sich erinnern sollte , unbedingt merken! In der tatsächlichen Entwicklung verfügen abstrakte Klassen im Allgemeinen über abstrakte Methoden. Andernfalls verliert die abstrakte Klasse ihre Bedeutung und unterscheidet sich nicht von einer gewöhnlichen Klasse!

Wenn eine gewöhnliche Klasse A eine abstrakte Klasse B erbt, muss die Unterklasse A alle abstrakten Methoden der übergeordneten Klasse B implementieren. Wenn Unterklasse A die abstrakte Methode der übergeordneten Klasse B nicht implementiert, muss Unterklasse A auch als abstrakte Klasse, also als abstrakte Klasse, definiert werden.

Schnittstelle, wie ich sie versteheSchnittstelle kann als Sonderfall einer abstrakten Klasse und Schnittstelle bezeichnet werden. Es gibt zwei zu viele Ähnlichkeiten und zu viele Unterschiede. Im Gegensatz dazu ist eine Schnittstelle eher eine Abstraktion des Verhaltens!

1. Schnittstelleneigenschaften

1), die

Methode

in der Schnittstelle ist standardmäßig öffentliche ZusammenfassungTyp: Wenn der Typ Mitgliedsvariable in der Schnittstelle nicht geschrieben wird, wird standardmäßig public static final verwendet. 2) Die Schnittstelle hat keine Konstruktionsmethode 3). Eine Klasse kann mehrere Schnittstellen implementieren.

2. Sie müssen über Schnittstellen Bescheid wissen

Schnittstellen können nur

-Variablen enthalten. Wenn nicht, ist die Standardeinstellung

führt zu einem Kompilierungsfehler. Alle Methoden in der public static finalpublic static final-Schnittstelle werden implizit als private-Methoden bezeichnet und können nur

-Methoden sein, die andere Schlüsselwörter verwenden, z. B.

public abstractprivate, protected, static, final. Modifikationen wie z da public abstract nicht kompiliert werden kann. 3. Schnittstellen-Missverständnisse

In vielen Artikeln im Internet heißt es, dass alle Methoden in Schnittstellen abstrakte Methoden sind und das tatsächlich herausgefunden hat , das reicht nicht aus, schauen wir uns einfach ein einfaches Programm an

package InterfaceDemo;

interface AA{   //接口AA
   default void hh(){
       System.out.println("123");
   };
}

class BB implements AA{  //实现接口
    
}

public class InterfaceDesign {

    public static void main(String[] args) {
        AA a=new BB(); //通过实现类创建实例
        a.hh();
    }
}
运行结果： 123

显然hh方法并不是抽象方法，但是这样设计就失去接口的意义了，实际开发中不会出现这样的代码，确实有点专牛角尖的韵味,所以我也不否认网上的言论，只是觉得不够严谨，我觉得大家还是注意一下比较好...如果面试官听到你这样的回答，可能对你刮目相看，会认为你是一个对知识极度向往、探索以及有个人思维想法的学习者 ~说白了，就是杠精，这里杠精是褒义词~

抽象类和接口本质区别

抽象类和接口本质区别主要从语法区别和设计思想两方面下手

1、语法区别

1.抽象类可以有构造方法，接口中不能有构造方法。

2.抽象类中可以有任何类型成员变量，接口中只能有public static final变量

3.抽象类中可以包含非抽象的普通方法，接口中的可以有非抽象方法，比如deaflut方法

4.抽象类中的抽象方法的访问类型可以是public，protected和（默认类型,虽然 eclipse下不报错，但应该也不行），但接口中的抽象方法只能是public类型的，并且默认即为public abstract类型。

5.抽象类中可以包含静态方法，接口中不能包含静态方法

6.抽象类和接口中都可以包含静态成员变量，抽象类中的静态成员变量的访问类型可以任意，但接口中定义的变量只能是public static final类型，并且默认即为public static final类型。

7.一个类可以实现多个接口，但只能继承一个抽象类。

2、设计思想区别

对于抽象类，如果需要添加新的方法，可以直接在抽象类中添加具体的实现（相当于写普通类的普通方法并添加方法体的实现代码），子类可以不进行变更；而对于接口则不行，如果接口进行了变更，则所有实现这个接口的类都必须进行相应的改动。这一点应该很好理解。

从设计角度来讲抽象类是对一种对类抽象，抽象类是对整个类整体进行抽象，包括属性、行为。而接口是对行为的抽象，接口是对类局部（行为）进行抽象。从某一角度来讲，接口更像是抽象的抽象！

怎么理解上面这段话呢？

理解二者设计思想的区别从程序员宜春和花姑娘（一头可爱的小母猪）的故事开始，程序员宜春每天过着三点一线的生活，不是吃就是睡觉，闲暇之余还会敲敲代码，而花姑娘就厉害了，每天都是一点一线的生活，不是吃就是睡觉，闲暇之余不是吃就是睡觉。程序员宜春和花姑娘都过着幸福安逸的生活，突然有一天，风起云涌，天射大便~天色大变~，万恶的产品经理来需求了，要设计一个程序员宜春和花姑娘的一个程序，要求使用抽象类或者接口去设计，这个时候你会怎么去设计，下面给出两个设计方案...

方案一：使用抽象类设计，分别设计eat、sleep、qiaoDaiMa方法，具体代码如下：

abstract class Myclass{
    public abstract void eat();
    public abstract void sleep();
    public abstract void qiaoDaiMa();
  }

方案二：使用接口设计，分别设计eat、sleep、qiaoDaiMa方法，具体代码如下：

interface Myclass{
    public abstract void eat();
    public abstract void sleep();
    public abstract void qiaoDaiMa();
  }

显然，不管是哪个类继承抽象类或者实现上面的接口，都会出现同样的状况：重写它们的抽象方法。
如果有一百个程序员宜春，上面的设计都是很好地得到解决。但是到花姑娘身上就不管用了，花姑娘不会敲代码这种高端操作啊！一百个花姑娘都重写的qiaoDaiMa方法都没有意义啊，显然这样设计有问题。

从上面可以看出，eat、sleep对于qiaoDaiMa方法不是同一范畴内的行为（方法）。实际上我们可以这样设计：定义一个抽象类，包含eat、sleep方法，再定义一个接口包含qiaoDaiMa方法，具体代码如下：

abstract class Myclass{
    public abstract void eat();
    public abstract void sleep();
   }

interface MyclassTwo{
    public abstract void qiaoDaiMa();
  }
  
class YiChun extends Myclass implements MyclassTwo{

          @Override
          public void eat() {
              
          }

          @Override
          public void sleep() {

          }

          @Override
          public void qiaoDaiMa() {

          }
      }

我们只要让一百个程序员宜春继承抽象类并实现接口就好了，而花姑娘就直接继承抽象类就好了。这样一设计，堪称完美...

同样的，这样讲述是很不负责的，为啥捏？因为你会发现，这样设计不管是抽象类还是接口好像没有什么区别，刚才的抽象类换成接口，接口换成抽象类，实现效果也一致，代码如下：

interface Myclass{
    public abstract void eat();
    public abstract void sleep();
   }

abstract class MyclassTwo{
    public abstract void qiaoDaiMa();
  }

所以，为了讲解清晰设计思想区别，程序员宜春和花姑娘的故事不得不继续讲下去...

我们都知道，可爱的小母猪一般都是粉色的对吧，这个时候我们的产品经理又改需求了。啥？产品经理家中一百只小猪有一只是黑白sai的，额...

万恶的产品经理只会无理改需求，可是产品经理永远不会知道他一味逼程序员，程序员自己都不知道自己有多优秀！

我们都知道，可爱的小母猪一般都是粉色的对吧，这个时候我们的产品经理又改需求了。啥？产品经理家中一百只小猪有一只是黑白sai的，额...

万恶的产品经理只会无理改需求，可是产品经理永远不会知道他一味逼程序员，程序员自己都不知道自己有多优秀！

那么这个时候，我们都知道,抽象类和接口都是可以有成员变量的，只不过接口比较苛刻只能是public static final正是因为这一点！抽象类和接口的设计精髓就在这里了，这个时候我们这样设计：

interface Myclass{
    public abstract void eat();
    public abstract void sleep();
   }

abstract class MyclassTwo{
    String color="red";
    public abstract void qiaoDaiMa();
  }

让宜春类这样设计

package AbstractTest;

interface Myclass {
    public abstract void eat();

    public abstract void sleep();
}

abstract class MyclassTwo {
    String color = "red";

    public abstract void qiaoDaiMa();
}

class YiChun extends MyclassTwo implements Myclass {

    @Override
    public void eat() {

    }

    @Override
    public void sleep() {

    }

    @Override
    public void qiaoDaiMa() {

    }
}

public class AbstractDemo {
    public static void main(String[] args) {
        YiChun yc = new YiChun();
    }

}

然而宜春对于color这个属性可以是不理睬的，可以当做不存在，除非宜春不嫌弃自己也是一只红sai佩奇哈哈哈....

而花姑娘类就要注意了！然后让产品经理家中的100只小猪设计代码如下;

package AbstractTest;

interface Myclass {
     public abstract void qiaoDaiMa();
}

abstract class MyclassTwo {
    String color = "red";

    public abstract void eat();
    public abstract void sleep();
  
}

class Pig extends MyclassTwo {

    @Override
    public void eat() {

    }

    @Override
    public void sleep() {

    }

}

public class AbstractDemo {
    public static void main(String[] args) {
        Pig p = new Pig ();
        String color = "blackWhite";
        System.out.println(color);
    }

}

其余的99只花姑娘就直接不用动了也就是不需要String color = "blackWhite";这一句代码，它的color属性默认是red了...

这个时候抽象类和接口就不能更换了，从而抽象类和接口的设计思想就很清晰了，你何识着咩啊~

本文来自 java入门 栏目，欢迎学习！

Das obige ist der detaillierte Inhalt vonVertieftes Verständnis abstrakter Klassen und Schnittstellen in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!