抽象类

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

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

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

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

3. 抽象方法 只需要声明方法，不能有方法体

父类抽象类:

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.test02();调用