接口

  接口：

       class类：底层员工

       abstract class类：中层

       接口：高层

package inter;
​
public interface Myinterface
{
    //一般建议：final类型的变量，变量名大小
    //默认全部是：public abstract
    static  int num=10;//等价于final int num=10; int num=10;
    public void eat();
}

  普通类：

 public class Person
       public void eat()
{
................
}

  抽象类：

 public abstract class Person
       public void eat()
{
................
}
public abstract void sleep();

 

  接口：interface

public interface Person
            //1.属性全部都是static final类型的
              //2.全是抽象方法
public abstract void eat();
public abstract void sleep();

           抽象方法：相当于一种约定：

                     public abstract void eat();

接口比抽象类更进一步的“抽象”

       继承：

                 is a

    接口：代表了一种能力，一种约定

                类 has a 接口

       例：门 有 锁的功能

     接口和抽象类一样，不能实例化(new)

    父类 eat();->子类（实现）

        接口 eat();->实现类

         继承：类

        实现：接口

   例：

              防盗门：分层

                                高级，入门

                                高级：接口public abstract void eat();

                                   入门：public void eat(){ ......}

             防盗门： 开门，关门

                             开锁，关锁

         防盗门是门：继承

        防盗门有锁的功能：接口

package inter;
​
public abstract class Door
{
    //开门，关门
    abstract void openDoor();
    abstract void closeDoor();
}

 

package inter;
​
public class TheftProofDoor extends Door implements Look
{
    @Override
    void openDoor() {
        System.out.println("开门...");
    }
    @Override
    void closeDoor() {
        System.out.println("关门...");
    }
    @Override
    public void openLock() {
        System.out.println("开锁...");
    }
    @Override
    public void closeLock() {
        System.out.println("关锁...");
    }
}
​

package inter;
​
public interface Look
{
    //开锁，关锁
    void openLock();
     void closeLock();
}

package inter;
​
public class Test
{
    public static void main(String[] args)
    {
        TheftProofDoor door=new TheftProofDoor();
        //回家：开锁 开门  关门  关锁
        door.openLock();
        door.openDoor();
        door.closeDoor();
        door.closeDoor();
    }
}

 

子类必须重写父类中所有抽象方法 实现类必须实现接口中的所有抽象方法 java中单继承，多实现

例：

     打印机： 墨盒：彩色，黑色

                    纸张：A4，B5

     实现类：真正制作打印机的厂商

package inter2;

public interface InkBox
{
    void printColor();//约定：可以打印任意颜色； 彩色，黑白
}

package inter2;

public interface Paper
{
    void printSize();//约定：打印时必须知道     A4  B6
}

package inter2;

public class PrinterA implements InkBox,Paper
{

    @Override
    public void printColor() {
        System.out.println("黑白....");
    }

    @Override
    public void printSize() {
        System.out.println("A4....");
    }
}

 

package inter2;

public class Test
{
    public static void main(String[] args) {
        PrinterA a=new PrinterA();
        a.printColor();
        a.printSize();
        B b=new B();
        b.printColor();
        b.printSize();
    }
}

package inter2;

public class B implements InkBox,Paper{
    @Override
    public void printColor() {
        System.out.println("黑白....");
    }

    @Override
    public void printSize() {
        System.out.println("B6.....");
    }
}

 

类：单继承

接口直接可以相互继承，多继承

public interface B extends A,C{ }

 

接口也可以实现多态

//接口 = 实现类

//父类 = 子类

接口不存在构造方法

接口：约定