接口：interface和implement关键字

对现实世界中不同类型的多种事务进行抽象的描述

接口是一种特殊的抽象

接口可以包含：

1，只能声明抽象方法

所以方法默认都是抽象方法（没有声明abstract关键字，自动添加）

所以方法默认都是公共方法（没有声明public关键字，自动添加）

public interface  A
{
void test();//==public abstract void test();
}

2.成员属性

所有成员属性默认为静态属性

int num=100;//==public static final int num=100;

不能包含成员方法，构造方法，静态代码块，非静态代码块；

接口中所有的抽象方法都有具体类（具体子类）来实现：

关键字：implement

一个具体类只能继承一个父类（java只能单向继承），实现指定接口；

——变相实现多继承

 

package code62403;

public interface FristInterface {
    void test(int a, int b);//public abstract void test(int a,int b);
    void voluem(int a,int b,int c);
}

package code62403;

public interface TwoInterface {
void input();
void output();
}

package code62403;

public class TestInterface {
    public static void main(String[] args) {
        FristInterface frist=new SubDemo();
        frist.test(1,2);
        frist.voluem(1,2,3);
        TwoInterface two=new SubDemo();
        two.input();
        two.output();
    }
}





abstract class Demo
{
    int number =100;
    boolean flag;
    abstract void dept();
}



 class suBDemo extends Demo implements FristInterface,TwoInterface
{
    void dept()
    {
        System.out.println("DEPT");
    }

    @Override
    public void test(int a, int b) {
        System.out.println("1");
    }

    @Override
    public void voluem(int a, int b, int c) {
        System.out.println("2");
    }

    @Override
    public void input() {
        System.out.println("3");
    }

    @Override
    public void output() {
        System.out.println('4');
    }
}

 

 

 

在项目中：如果接口中定义了属性（默认静态常量），那么在该接口中不会再定义方法了；

一个类可以实现多个接口；（常量接口：该接口只会静态常量，//不会报错，但是后期不易维护  ）；

如果接口中声明了属性（默认静态常量），那么不会再该接口中声明其他方法；

常量接口：该接口只定义静态常量；

接口就是一种规范，也是一种能力和约定；

当父类的中的方法种类无法满足子类的需求时，可以使用接口扩充子类的能力；

——接口是不能实现接口的；

——接口能继承接口，并可以继承多个接口：

接口与抽象类的区别：

相同点 ：

可以编译字节码

不能被实例化

可以作为引用类型（多态）

具有Object类中所定义的所有方法

不同点：

所有属性的是公共的静态常量//public static final修饰；

所有的方法都是公共抽象的//public abstract修饰；

没有静态代码块，非静态代码块，构造方法；

接口回调

使用一个接口的引用，调用其具体实现类中的该接口实现方法；

 

package code62403;

public class TestCallInterface {
    public static void main(String[] args) {
        Usb m = new Mouse();
        Usb k = new Keyboard();
        Disk d=new Disk();
        Computer c=new Computer();
        c.setUsb(m);
        c.on();
        c.setUsb(k);
        c.on();
        c.setUsb(d);
        c.on();
    }
}
interface Usb{
    public abstract void service();
}
class Mouse implements Usb
{
    @Override
    public void service() {
        System.out.println("鼠标启动了");
    }
}
class Keyboard implements Usb
{
    @Override
    public void service() {
        System.out.println("键盘开始工作了");
    }
}
class disk implements Usb{
    @Override
    public void service() {
        System.out.println("disk开始工作了");
    }
}
//普通实现方式
/*
class Computer
{
    Usb mouse;
    Usb keyboard;

   */
/* public Usb getMouse() {
        return mouse;
    }

    public void setMouse(Usb mouse) {
        this.mouse = mouse;
    }

    public Usb getKeyboard() {
        return  keyboard;
    }

    public void setKeyboard(Usb keyboard) {
        this.keyboard = keyboard;
    }*//*


    public void on(Usb usb)
    {
            usb.service();
    }
}
*/
//进化方式
class Computer
{
    private Usb usb;

    public Usb getUsb() {
        return usb;
    }

    public void setUsb(Usb usb) {
        this.usb = usb;
    }
    public void on()
    {
        usb.service();
    }
}