抽象

抽象类：

父类中的至少有一个抽象的方法

1 **抽象方法**需要有abstract关键字的修饰，关键字可以在public关键字的后面，也可以在public的前面

2 **抽象类**也需要有abstract关键字修饰，关键字可以在public关键字的后面，也可以在public的前面

3 一个**抽象类**中至少要有一个**抽象方法**

4 **抽象方法** 只需要声明方法，不能有方法体

父类抽象类：

public abstract class Door {
    
    
    /*public void open() {
        System.out.println("门的作用之一是开门");
    }

    public void colse() {
        System.out.println("门的作用之二是关门");
    }*/

    public abstract void open() ;

    public abstract void close() ;
}

子类一键盘锁门：

public class KeypadDoor extends Door{
    public void open() {
        System.out.println("按键盘输入密码开门");
    }

    public void close() {
        System.out.println("拉上即可自动锁门");
    }
}

子类二 电动门：

public class PowerDoor extends Door{
    public void open() {
        System.out.println("按遥控器开门");
    }

    public void close() {
        System.out.println("按遥控器关门");
    }
}

测试并调用

public class Demo01 {
    public static void main(String[] args) {
        KeypadDoor keypadDoor = new KeypadDoor();
        keypadDoor.open();
        keypadDoor.close();

        PowerDoor powerDoor = new PowerDoor();
        powerDoor.open();
        powerDoor.close();

匿名类：

Door door = new Door() {
    @Override
    public void open() {
        System.out.println("临时实现的开门方法");
    }

    @Override
    public void close() {
        System.out.println("临时实现的关门方法");
    }
};

door.open();
door.close();

接口

1 关键字interface，实现类的关键字 implements 接口的名字

2 接口中写方法的声明，没有方法体

3 接口方法默认权限全部是public，因此，public可省略

4 实现类中需要全部实现接口中出现的未实现的方法

案例：

public interface Door {
    // 方法的声明（签名）
    public void open();

    public void close();
}

实现类：

public class KeypadDoor implements Door{
    @Override
    public void open(){
        System.out.println("键盘门打开");
    }

    @Override
    public void close(){
        System.out.println("键盘门关闭");
    }
}

实现类：

public class PowerDoor implements Door{
    @Override
    public void open() {
        System.out.println("电动门开门");
    }

    @Override
    public void close() {
        System.out.println("电动门关门");
    }
}

接口没有直接new，创建对象，但是可以临时创建一个匿名的实现类

Door door = new Door() {
    @Override
    public void open() {
        System.out.println("临时的实现类开门");
    }

    @Override
    public void close() {
        System.out.println("临时的实现类关门");
    }
};

door.open();
door.close();

接口中的静态常量

public interface Door {
    //静态常量
    String des="是个门，注意安全";
 }

接口中的默认方法和静态方法

public interface Door {
    //静态常量
    String des="是个门，注意安全";
    // 方法的声明（签名）
    public void open();

    public void close();

    public default void test01() {

        System.out.println("接口中的默认测试方法");
    }

    public static void test02() {

        System.out.println("接口中的静态方法");
    }
}
public class Demo02 {
    public static void main(String[] args) {
        keypadDoor.test01();
        //keypadDoor.test02();
        //Door.test02();
        Door.test02();
    }
}    

接口中默认方法只能通过实现类的对象KeypadDoor.test01();调用

接口中的静态方法只能通过接口名.方法Door.test();调用

接口可以多继承

演示：

public interface GrandFather {
    public void diaoyu();
}

public interface Father {
    public void chouyan();
}

public interface Son {
    public void play();
}

多继承：一个接口可以同时继承很多个接口

public interface Temp extends GrandFather,Father,Son{

}

子类必须实现抽象的父类中或抽象的祖先类中为实现抽象的方法

祖先类中的抽象的方法，如果在抽象的父类中实现过，子类可以选择实现，也可以选择不实现