# 抽象类：

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

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

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

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

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

######      **父类抽象类**

```java
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("拉上即可自动关门");
}
}

子类二：电动门

ublic 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.close();
        powerDoor.open();
    }
}

匿名类

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

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

接口

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

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

3. 接口方法默认权限全部是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.close();
        door.open();

接口中的静态常量

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 keypadDoor = new KeypadDoor();
        keypadDoor.open();
        keypadDoor.close();


        keypadDoor.test01();
      //  keypadDoor.teat02();
        com.company.Demo02.Door.test02();
       // com.company.Demo02.Door.test01();
}}

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

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

接口的多继承

演示：

public interface GrandFather {
    public  void dioayu();

}

public interface Father {
    public  void chouyan();
}

public interface Son {
    public void play();
}

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

//接口的多继承
public interface Temp extends GrandFather ,Father,Son {
}

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

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