抽象类：

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

1. 抽象方法需要有 abstract 关键字修饰，关键字可以在public关键字后面，也可以在public的前面
2. 抽象类也需要abstract关键字修饰，关键字可以在public关键字后面，也可以在public的前面
3. 一个抽象类中至少要有一个抽象方法
4. 抽象方法 只需要声明方法，不能有方法体

父类抽象类：

public abstract class Door {
   /* public void open(){
        System.out.println("门的作用之一是开门");
    }
    public void close(){
        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("按遥控器关门");
    }
}

测试并调用

匿名类：

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.test01():
        Door.test02();
    }
}

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

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

接口可以多继承

演示：

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

子类必须实现抽象的父类中或抽象的祖类中积累的未实现的抽象方法

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