Compréhension approfondie des classes abstraites et des interfaces en Java

Je crois que tout le monde ressent cela : il y a trop de similitudes et trop de différences entre les classes abstraites et les interfaces. Ces deux éléments confondent souvent les débutants Que ce soit dans la programmation réelle ou lors des entretiens, les classes abstraites et les interfaces sont particulièrement importantes ! J'espère qu'après avoir lu cet article, tout le monde pourra comprendre sereinement les deux...

Cours abstrait tel que je le comprends

1. Les classes abstraites ont la même saveur que les classes

1) Les classes abstraites peuvent être utilisées comme les classes pour hériter.
2), les classes abstraites peuvent avoir tous les composants qu'une classe peut avoir [y compris les constructeurs, les composants de modification statique, etc.]

Les classes abstraites sont telles que leur nom les définit, elles sont aussi une classe A

2. Méthode abstraite

Il faut bien connaître avant de parler des différents charmes Méthode abstraite ：

1), la méthode abstraite n'a pas de corps de méthode
2), la méthode abstraite doit être modifiée avec abstractmot-clé
3), la classe avec la méthode abstraite doit C'est une classe abstraite
4). La méthode abstraite doit être public ou protected Par défaut, elle est par défaut public

. méthodes

3. Le charme étrange des classes abstraites et des classes

1), les classes abstraites doivent être modifiées avec le mot-clé abstract , et les classes avec des modifications abstraites C'est une classe abstraite !
2), les classes abstraites peuvent ou non avoir des méthodes abstraites
3), bien que les classes abstraites aient des constructeurs, elles ne peuvent pas être utilisées pour créer directement des instances d'objet
4), les classes abstraites ne peuvent pas être utilisées final , privateModification
5) Les classes abstraites externes ne peuvent pas être modifiées avec Static, mais les classes abstraites internes peuvent être déclarées avec static. Le code pour comprendre cette phrase est le suivant :

//定义一个抽象类A
abstract class A{
   //定义一个内部抽象类B
    static abstract class B{  //static定义的内部类属于外部类
        public abstract void saoMethod();
    }
}

class C extends A.B{

    public void saoMethod(){
        System.out.println("======saoMethod方法执行了======");
    }
}
public class StaticDemo {

    public static void main(String[] args) {
        A.B ab = new C();//向上转型
        ab.saoMethod();
    }

}

运行结果：  ======saoMethod方法执行了======

Certaines chaussures pour enfants sont tellement déroutantes C extends A.BDe quel genre d'opération cool s'agit-il ? Oui, lorsque la classe abstraite interne déclarée à l'aide de static est équivalente à une classe abstraite externe, le nom de la classe est exprimé sous la forme "classe externe. classe interne" lors de l'héritage. Ce genre d'opération cool est vraiment sûr et maigre.

La classe abstraite est une classe spéciale. Il y a une différence essentielle entre la classe abstraite et la classe ordinaire

4. Les classes abstraites existent pour l'héritage. Si vous définissez une classe abstraite mais n'en héritez pas, la classe abstraite que vous créez n'aura aucun sens !

Bien que les classes abstraites aient des constructeurs, elles ne peuvent pas être directement Être. instancié

, la création d'un objet implique une transformation vers le haut, principalement pour être appelé par ses sous-classes Il y a aussi la phrase selon laquelle les classes abstraites ne peuvent pas avoir de méthodes abstraites, c'est juste une chose importante à retenir Concept, être je m'en souviendrai sûrement ! Dans le développement réel, les classes abstraites ont généralement des méthodes abstraites, sinon la classe abstraite perdra son sens et ne sera pas différente d'une classe ordinaire !

Si une classe ordinaire A hérite d'une classe abstraite B, alors la sous-classe A doit implémenter toutes les méthodes abstraites de la classe parent B. Si la sous-classe A n'implémente pas la méthode abstraite de la classe parent B, la sous-classe A doit également être définie comme une classe abstraite, c'est-à-dire une classe abstraite.

L'interface telle que je la comprendsL'interface peut être considérée comme un cas particulier de classe abstraite. La classe abstraite et l'interface sont deux. trop de similitudes et trop de différences. En revanche, une interface s’apparente davantage à une abstraction du comportement !

1. Caractéristiques de l'interface

1), la

méthode

dans l'interface est par défaut public abstractType, si le type variable membre dans l'interface n'est pas écrit, sa valeur par défaut est public static final. 2) L'interface n'a pas de méthode de construction 3) L'interface peut implémenter un "héritage multiple". Une classe peut implémenter plusieurs interfaces. Le format d'implémentation consiste à les séparer directement par des virgules.

2. Vous devez connaître les interfaces

Les interfaces ne peuvent contenir que des variables

Si elles ne sont pas écrites, la valeur par défaut est

Modification avec public static final. entraînera un échec de compilation. Toutes les méthodes de l'interface public static finalprivate seront implicitement désignées comme des méthodes

et ne pourront être que des méthodes

, en utilisant d'autres mots-clés, tels que public abstractpublic abstractprivate, protected, static, final Modifications telles que car ne parviendra pas à compiler.

3. Malentendus liés aux interfaces

De nombreux articles sur Internet disent que toutes les méthodes des interfaces sont des méthodes abstraites. Le blogueur est revenu en arrière et a fait des recherches et a découvert qu'en fait. , ce n'est pas suffisant, sérieusement, regardons simplement un programme simple

.

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入门 栏目，欢迎学习！

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!