Java não entendem pouco conhecimento ---- Interface (cont.)

Usar interfaces em Java

formato:

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

}

 

Class [] interfaces de cumprir ==> implementos

nome da classe da classe implementa a 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 podem seguir uma pluralidade de interfaces, cumprindo com uma pluralidade de interfaces, todos os atributos padrão para cada interface deve implementar os métodos abstratos

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

 

Ele pode ser herdada entre as interfaces, e pode ser herança múltipla! compatível com versões anteriores

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

Se a interface E uma classe herda, para alcançar todos os atributos padrão para o CDE método abstrato 

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

    @Override
    public void testD() {

    }

    @Override
    public void testE() {

    }
}

 

(JDK1.8 novos recursos)

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

 

Use resumo requisitos de interface

1. Interface
   atributos variáveis de membro padrão public static final
   membros do método abstrato pública
2. Uma classe não-abstrata Interfaces compatíveis, todas as interfaces necessárias para concluir o atributo padrão forçado como um membro do método abstrato pública
3. Permitir que se estende entre a interface e a herança de interface e herança de interface permite que uma pluralidade de interfaces: um interface de se estende B, C
   de vida: problemas de compatibilidade de protocolos para trás, tal como os dispositivos de suportes de interface USB 3.0 2.0 e 1.0
4. Você pode usar os métodos de modificação de interface palavra-chave padrão, o método padrão tem um corpo de método, ele pode ser considerado implementação não obrigatórias não é necessária para garantir a conformidade com interface não-abstrato, JDK1.8 novos recursos

interface de apresentação de vida

 

从生活中映射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());

    }
}