05.Bases de Java - Interface

Concepts de base

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.

---

Exemple d'étude

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");
    }
}

---

Interface imbriquée

Il existe deux formes d'interface imbriquée :

• Définir une interface dans une classe

• Définir une interface au sein d'une interface.

---

1. Définir l'interface dans la classe

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());

---

2. Définissez l'interface dans l'interface

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();      
    }
}

---

Interface et classe abstraite

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.

---

1. Différence de syntaxe

• 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.

---

2. Utiliser la différence

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) !