Explication détaillée des interfaces et des classes abstraites en Java

Cet article présente principalement des informations pertinentes pour une compréhension approfondie des interfaces Java et des classes abstraites. J'espère qu'à travers cet article, tout le monde pourra comprendre l'utilisation des interfaces d'application et des classes abstraites. Les amis dans le besoin pourront s'y référer

.

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

Pour la programmation orientée objet, l'abstraction est l'une de ses fonctionnalités majeures. En Java, l'abstraction POO peut être matérialisée sous deux formes : des interfaces et des classes abstraites. Les deux ont trop de similitudes et trop de différences. Beaucoup de gens pensent qu’ils peuvent être utilisés de manière interchangeable lors de leur premier apprentissage, mais ce n’est pas le cas dans la réalité. Aujourd'hui, nous allons découvrir les interfaces et les classes abstraites en Java.

1. Classes abstraites

Avant de comprendre les classes abstraites, comprenons d'abord les méthodes abstraites. Une méthode abstraite est un type particulier de méthode : elle n’a qu’une déclaration, mais aucune implémentation concrète. Le format de déclaration d'une méthode abstraite est :

abstract void fun();

Les méthodes abstraites doivent être modifiées avec le mot clé abstract. Si une classe contient des méthodes abstraites, la classe est appelée classe abstraite. Les classes abstraites doivent être modifiées avec le mot-clé abstract avant la classe. Étant donné que les classes abstraites contiennent des méthodes qui n'ont pas d'implémentation concrète, les objets ne peuvent pas être créés à l'aide de classes abstraites.

Ce qui suit est à noter : dans le livre "JAVA Programming Thoughts", une classe abstraite est définie comme une "classe contenant des méthodes abstraites", mais plus tard, il a été découvert que si une classe ne contient pas de méthodes abstraites, il est juste décoré d'abstrait. C'est aussi un cours abstrait. En d’autres termes, les classes abstraites ne doivent pas nécessairement contenir des méthodes abstraites. Personnellement, je pense que c'est une question délicate, car si une classe abstraite ne contient aucune méthode abstraite, pourquoi devrait-elle être conçue comme une classe abstraite ? Retenons donc ce concept pour l’instant sans entrer dans le pourquoi.

[public] abstract class ClassName {
  abstract void fun();
}

On peut voir à partir d'ici que les classes abstraites existent pour l'héritage Si vous définissez une classe abstraite mais n'en héritez pas, vous avez donc créé ceci. classe abstraite en vain, car vous ne pouvez rien en faire. Pour une classe parent, si l'une de ses méthodes n'a aucun sens lorsqu'elle est implémentée dans la classe parent et doit être implémentée différemment en fonction des besoins réels de la sous-classe, alors cette méthode peut être déclarée comme méthode abstraite. la classe aussi Cela devient une classe abstraite.

Une classe qui contient des méthodes abstraites est appelée une classe abstraite, mais cela ne signifie pas que les classes abstraites ne peuvent avoir que des méthodes abstraites. Comme les classes ordinaires, elles peuvent également avoir des variables membres et des méthodes membres ordinaires. Notez qu'il existe trois différences principales entre les classes abstraites et les classes ordinaires :

1) Les méthodes abstraites doivent être publiques ou protégées (car si elles sont privées, elles ne peuvent pas être héritées par les sous-classes, et les sous-classes ne peuvent pas implémenter la méthode) Dans les cas provinciaux, la valeur par défaut est publique.

2) Les classes abstraites ne peuvent pas être utilisées pour créer des objets

3) Si une classe hérite d'une classe abstraite, la sous-classe doit implémenter la méthode abstraite du parent ; classe. Si la sous-classe n'implémente pas la méthode abstraite de la classe parent, la sous-classe doit également être définie comme classe abstraite.

Dans d'autres aspects, il n'y a aucune différence entre les classes abstraites et les classes ordinaires.

2. Interface

L'interface est appelée interface en anglais. En génie logiciel, l'interface fait généralement référence à des méthodes ou des fonctions appelées par d'autres. À partir de là, nous pouvons réaliser l’intention originale du concepteur du langage Java, qui est l’abstraction du comportement. En Java, la forme de définition d'une interface est la suivante :

[public] interface InterfaceName {

}

Les interfaces peuvent contenir des variables et des méthodes. Mais veuillez noter que les variables de l'interface seront implicitement désignées comme variables finales statiques publiques (et elles ne peuvent être que des variables finales statiques publiques. Les modifier avec private signalera une erreur de compilation), tandis que les méthodes seront implicitement désignées comme publiques abstraites. Et il ne peut s'agir que d'une méthode abstraite publique (la modification avec d'autres mots-clés, tels que private, protected, static, final, etc. signalera une erreur de compilation), et toutes les méthodes de l'interface ne peuvent pas avoir d'implémentations spécifiques, c'est-à-dire disons, les méthodes de l'interface doivent Ce sont toutes des méthodes abstraites. De là, vous pouvez vaguement voir la différence entre les interfaces et les classes abstraites. Les interfaces sont un type extrêmement abstrait. Elles sont plus « abstraites » que les classes abstraites et les variables ne sont généralement pas définies dans les interfaces.

Pour qu'une classe suive un ensemble spécifique d'interfaces, vous devez utiliser le mot-clé Implements. Le format spécifique est le suivant :

class ClassName implements Interface1,Interface2,[....]{
}

Comme vous pouvez le voir, permettre à une classe de suivre plusieurs interfaces spécifiques. Si une classe non abstraite est conforme à une interface, elle doit implémenter toutes les méthodes de l'interface. Pour une classe abstraite qui suit une interface, il n'est pas nécessaire d'implémenter les méthodes abstraites dans l'interface.

3. La différence entre les classes abstraites et les interfaces

1) Différences au niveau de la syntaxe

1) Les classes abstraites peuvent fournir des membres. méthodes Détails d'implémentation, et seules les méthodes abstraites publiques peuvent exister dans les interfaces ;
2) Les variables membres dans les classes abstraites peuvent être de différents types, tandis que les variables membres dans les interfaces ne peuvent être que de type final statique public ; ne peut pas contenir de blocs de code statiques et de méthodes statiques, tandis que les classes abstraites peuvent avoir des blocs de code statiques et des méthodes statiques
4) Une classe ne peut hériter que d'une seule classe abstraite, mais une classe peut implémenter plusieurs interfaces ;

2. Différences au niveau de la conception

1）抽象类是对一种事物的抽象，即对类抽象，而接口是对行为的抽象。抽象类是对整个类整体进行抽象，包括属性、行为，但是接口却是对类局部（行为）进行抽象。举个简单的例子，飞机和鸟是不同类的事物，但是它们都有一个共性，就是都会飞。那么在设计的时候，可以将飞机设计为一个类Airplane，将鸟设计为一个类Bird，但是不能将 飞行 这个特性也设计为类，因此它只是一个行为特性，并不是对一类事物的抽象描述。此时可以将 飞行 设计为一个接口Fly，包含方法fly( )，然后Airplane和Bird分别根据自己的需要实现Fly这个接口。然后至于有不同种类的飞机，比如战斗机、民用飞机等直接继承Airplane即可，对于鸟也是类似的，不同种类的鸟直接继承Bird类即可。从这里可以看出，继承是一个 “是不是”的关系，而 接口 实现则是 “有没有”的关系。如果一个类继承了某个抽象类，则子类必定是抽象类的种类，而接口实现则是有没有、具备不具备的关系，比如鸟是否能飞（或者是否具备飞行这个特点），能飞行则可以实现这个接口，不能飞行就不实现这个接口。

2）设计层面不同，抽象类作为很多子类的父类，它是一种模板式设计。而接口是一种行为规范，它是一种辐射式设计。什么是模板式设计？最简单例子，大家都用过ppt里面的模板，如果用模板A设计了ppt B和ppt C，ppt B和ppt C公共的部分就是模板A了，如果它们的公共部分需要改动，则只需要改动模板A就可以了，不需要重新对ppt B和ppt C进行改动。而辐射式设计，比如某个电梯都装了某种报警器，一旦要更新报警器，就必须全部更新。也就是说对于抽象类，如果需要添加新的方法，可以直接在抽象类中添加具体的实现，子类可以不进行变更；而对于接口则不行，如果接口进行了变更，则所有实现这个接口的类都必须进行相应的改动。

下面看一个网上流传最广泛的例子：门和警报的例子：门都有open( )和close( )两个动作，此时我们可以定义通过抽象类和接口来定义这个抽象概念：

abstract class Door {
  public abstract void open();
  public abstract void close();
}

或者：

interface Door {
  public abstract void open();
  public abstract void close();
}

但是现在如果我们需要门具有报警alarm( )的功能，那么该如何实现？下面提供两种思路：

1）将这三个功能都放在抽象类里面，但是这样一来所有继承于这个抽象类的子类都具备了报警功能，但是有的门并不一定具备报警功能；

2）将这三个功能都放在接口里面，需要用到报警功能的类就需要实现这个接口中的open( )和close( )，也许这个类根本就不具备open( )和close( )这两个功能，比如火灾报警器。

从这里可以看出， Door的open() 、close()和alarm()根本就属于两个不同范畴内的行为，open()和close()属于门本身固有的行为特性，而alarm()属于延伸的附加行为。因此最好的解决办法是单独将报警设计为一个接口，包含alarm()行为,Door设计为单独的一个抽象类，包含open和close两种行为。再设计一个报警门继承Door类和实现Alarm接口。

interface Alram {
  void alarm();
}

abstract class Door {
  void open();
  void close();
}
/**
 * Java学习交流QQ群：589809992 我们一起学Java！
 */
class AlarmDoor extends Door implements Alarm {
  void oepn() {
   //....
  }
  void close() {
   //....
  }
  void alarm() {
   //....
  }
}

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!