Maison >Java >javaDidacticiel >05.Bases de Java - Interface
Interface (interface) En génie logiciel, l'interface fait généralement référence à des méthodes ou des fonctions appelées par d'autres. . Cela va encore plus loin avec les concepts abstraits.
En Java, une interface est définie via le mot-clé interface, et l'interface est implémentée via le mot-clé Implements.
On peut comprendre une interface comme une classe extrêmement abstraite, car elle est plus abstraite qu'une classe abstraite.
Regardons les caractéristiques de l'interface à travers des exemples :
Définir une interface
// 1.接口,访问权限只能是 默认(包访问权限)或 publicpublic interface Parent { // 2.成员变量,准确来说应该叫常量。具有以下特点: // 2.1.访问权限只能是 public (缺省也代表 public) ,修饰符只能是 final & static public final static String WORD = "a"; // 2.2.即使不指定,默认也是被 public fainl static 修饰 String NAME = "b"; // 2.3.不能存在空的 final 变量 ,如 int num; 但是可以被非常量表达式初始化 int num = new Random().nextInt(100); // 3.抽象方法,访问权限只能是 默认(包访问权限)或 public public abstract void print(); abstract void print(int i); // 4.普通方法,访问权限只能是 默认(包访问权限)或 public public void play(); void play(int i); }
Implémenter une interface
public class Son implements Parent { @Override public void print() { System.out.println("I am Son"); } @Override public void play() { System.out.println("Son is playing"); } }
Il existe deux formes d'interface imbriquée :
Définir une interface dans une classe
Définir une interface au sein d'une interface.
L'interface est imbriquée dans la classe et présente les caractéristiques suivantes :
Il n'y a aucune restriction sur les droits d'accès de l'interface, vous pouvez utiliser la modification privée
Les droits d'accès des méthodes/méthodes abstraites/variables sont cohérent avec l'interface externe
Ce qui suit est vérifié à travers un exemple :
public class Demo { // 内部接口 private interface A { void f(); } // 内部类 class AImpl implements A { @Override public void f() { System.out.println("AImpl.f()"); } } A getA(){ return new AImpl(); } private A a; public void receive(A a){ this.a = a; a.f(); } }
Regardons son processus d'appel :
Demo demo = new Demo();// 错误,因为 A 是私有接口,不可被外部访问 // Demo.A a = demo.getA(); // 因为 A 接口不可视,所以只能通过内部类来访问 Demo.AImpl a = (Demo.AImpl) demo.getA();a.f();// 或者是这样 demo.receiveA(demo.getA());
Définissez l'interface dans l'interface À l'exception de l'appel, c'est la même chose que l'interface ordinaire.
public interface Demo { // 内部接口 interface A { void play(); } void print(); }public class DemoImpl implements Demo,Demo.A{ @Override public void play() { System.out.println("DemoImpl.play()"); } @Override public void print() { System.out.println("DemoImpl.print()"); } }public class Test{ public static void main(String[] args) { // 向上转型,只能调用 print() Demo demo = new DemoImpl(); // 向上转型,只能调用 play() Demo.A a = new DemoImpl(); } }
Comme mentionné ci-dessus, nous pouvons comprendre l'interface comme une classe extrêmement abstraite, car elle est plus abstraite que le classe abstraite Plus abstrait.
Dans l'application réelle, il existe encore une différence entre les deux.
Les classes abstraites peuvent contenir des méthodes non abstraites, alors que seules les méthodes abstraites peuvent exister dans les interfaces.
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 des constantes statiques publiques (public static final).
Les classes abstraites peuvent avoir des blocs de code statiques et des méthodes statiques, mais les interfaces ne peuvent pas contenir de blocs de code statiques et de méthodes statiques.
Une classe ne peut hériter d' qu'une classe abstraite, mais une classe peut implémenter plusieurs interfaces.
La classe abstraite est l'abstraction de l'ensemble (propriétés, comportement), tandis que l'interface est l'abstraction de la chose Abstraction locale (comportementale).
Pour donner un exemple simple, les avions et les oiseaux sont des types de choses différents, mais ils ont tous une chose en commun, c'est qu'ils peuvent voler.
Lors de la conception, vous pouvez concevoir l'avion comme un avion et l'oiseau comme un oiseau.
Mais la caractéristique du vol ne peut pas être conçue comme une classe, il s'agit donc uniquement d'une caractéristique comportementale et non d'une description abstraite d'une classe de choses.
À ce stade, Flight peut être conçu comme une interface Fly, y compris la méthode fly(), puis Airplane et Bird implémentent respectivement l'interface Fly en fonction de leurs propres besoins.
Ensuite, comme pour les différents types d'avions, comme les avions de combat, les avions civils, etc., ils peuvent directement hériter de la classe Avion. Il en va de même pour les oiseaux. Différents types d'oiseaux peuvent directement hériter de la classe Oiseau. .
On peut voir à partir d'ici que l'héritage est une relation "est-ce que c'est", tandis que l'implémentation de l'interface est une relation "est-ce que c'est".
Si une classe hérite d'une classe abstraite, la sous-classe doit être du type de classe abstraite, et l'implémentation de l'interface est liée à son existence ou non, par exemple si un oiseau peut voler (ou s'il a le capacité à voler Cette fonctionnalité), si vous pouvez voler, vous pouvez implémenter cette interface, si vous ne pouvez pas voler, vous ne pouvez pas implémenter cette interface.
Ce qui précède est le contenu de 05.Java Basics - Interface Pour plus de contenu connexe, veuillez faire attention au site Web PHP chinois (www.php.cn) !