抽象

抽象类：

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

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("按遥控器关门");
    }
}

测试并调用

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

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

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

演示：

public interface GrandFather {
    public void diaoyu();
}

public interface Son {
    public void Player();
}

public interface Father {
    public void chouyan();
}

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

public interface Temp extends GrandFather,Father,Son{

}

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

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