Java ne comprend pas peu de connaissances ---- Interface (suite).

Utiliser les interfaces en Java

Format:

interface 接口名{
    成员变量（缺省属性public static final）
    成员方法（缺省属性abstract修饰）

}

 

Classe [] interfaces conformes ==> outils

nom de classe de la classe implémente l'interface {}
 

/**
 * 接口演示
 * @Author kk
 * @Date 2020/3/10 19:33
 */
interface A{
    int num = 10;
    public void test();
}

/**
 * 类TypeA遵从接口A
 */
class TypeA implements A{
    @Override
    public void test() {
        System.out.println(num);
        System.out.println("TypeA类遵从接口A，实现接口A中缺省属性为abstract的成员方法");
    }
}
public class Demo1 {
    public static void main(String[] args) {
        TypeA typeA = new TypeA();
        typeA.test();
    }
}

 

Classe peut suivre une pluralité d'interfaces, en respectant une pluralité d'interfaces, tous les attributs par défaut pour chaque interface doit implémenter les méthodes abstraites

interface A{
    int num = 10;
    public void test();
}
interface B{
    public  void testB();
}
class TypeA implements A,B{
    @Override
    public void test() {
        System.out.println(num);
        System.out.println("TypeA类遵从接口A，实现接口A中缺省属性为abstract的成员方法");
    }

    @Override
    public void testB() {
        
    }
}

 

Il peut être héritée entre les interfaces, et peut être l'héritage multiple! rétrocompatible

interface C{
    void testC();
}
interface D{
    void testD();
}
interface E extends C, D{
    void testE();
}

Si une interface de classe E, pour atteindre tous les attributs par défaut pour la méthode abstraite CDE 

public class Demo2 implements E{
    @Override
    public void testC() {
        
    }

    @Override
    public void testD() {

    }

    @Override
    public void testE() {

    }
}

 

(JDK1.8 nouvelles fonctionnalités)

interface F{
    /*
        接口当中的默认方法
        default
        default修饰的方法，是拥有方法体的
            1.接口提供了最基本的处理方法，你可以选择重写也可以不重写，
            这叫做默认方法
            2.非强制实现方法，可选完成
     */
    default void testF(){
        System.out.println("接口中的默认方法，非强制重写");
    }
}
class TypeC implements F{
    //遵从了接口F，没有任何的错误，因为接口中的方法是default，非强制实现
}
public class Demo3 {
    public static void main(String[] args) {
        new TypeC().testF();
    }
}

 

Utiliser les exigences d'interface sommaire

1. Interface des
   variables membres attributs par défaut public static
   membres de la méthode abstraite publique
2. Une classe non abstraite Interface interfaces compatibles, toutes les interfaces nécessaires pour compléter l'attribut par défaut forcé en tant que membre de la méthode abstraite publique
3. Laisser se prolonge entre l'interface et l'héritage d'interface et l' héritage d'interface permet à une pluralité d'interfaces: une interface A prolonge B, C
   Vie: problèmes de compatibilité en arrière de protocole, tels que les supports d'interface périphériques USB3.0 2.0 et 1.0
4. Vous pouvez utiliser les méthodes de modification d'interface de mot-clé par défaut, la méthode par défaut a un corps de méthode, on peut considérer la mise en œuvre non obligatoire n'est pas nécessaire pour assurer la conformité avec l'interface non-abstraite, JDK1.8 nouvelles fonctionnalités

interface de présentation vie

 

从生活中映射USB接口
    interface USB
        规定USB设备必须完成的方法
        void connect();

鼠标类 implements USB
    鼠标是一个USB设备，必须完成connect方法
键盘类 implements USB
    键盘是一个USB设备，必须完成connect方法
USB接口在电脑上，我们需要使用USB接口

package Test01;

/**
 * @Author kk
 * @Date 2020/3/10 20:26
 */
interface USB{
    /*
        要求所有的USB设备，必须完成的方法，告知USB接口连接之后完成的
        功能是什么
     */
    void connect();
}

/**
 * 鼠标类，遵从USB接口，实现connect方法
 */
class Mouse implements USB{
    @Override
    public void connect() {
        System.out.println("鼠标连接USB接口，控制光标");
    }
}
/**
 * 键盘类，遵从USB接口，实现connect方法
 */
class Keyboard implements USB{
    @Override
    public void connect() {
        System.out.println("键盘连接USB接口，输入设备");
    }
}

/**
 * PC电脑类，使用USB接口，需要通过USB接口连接一个USB设备
 */
class PC{
    /**
     * 电脑类连接USB接口的方法，这里需要的是一个USB设备
     * @param usb USB接口对应的设备
     */
    public void usbConnect(USB usb){
        //usb设备执行connect方法
        usb.connect();
    }
}

/**
 * Logi类，继承鼠标Mouse类
 *  1.这是一个鼠标设备
 *  2.Logi间接遵从USB接口，这也是一个USB设备
 */
class Logi extends Mouse{
    @Override
    public void connect(){
        System.out.println("我是一个Logi鼠标");
    }
}

/**
 * Filco继承Keyboard类
 *  1.这是一个键盘设备
 *  2.这也是间接遵从了USB接口，是一个USB设备
 */
class Filco extends Keyboard{
    @Override
    public void connect(){
        System.out.println("我是一个Filco键盘");
    }
}
public class Demo1 {
    public static void main(String[] args) {
        //电脑中有个方法是使用USB接口连接USB设备
        PC pc = new PC();

        //鼠标和键盘都是USB设备
        Mouse mouse = new Mouse();
        Keyboard keyboard = new Keyboard();

        //电脑需要通过USB接口连接USB设备，鼠标和键盘都有一个相同的USB接口
        pc.usbConnect(mouse);
        pc.usbConnect(keyboard);

        //传入一个Logi对象
        pc.usbConnect(new Logi());
        //传入一个Filco对象
        pc.usbConnect(new Filco());

    }
}