抽象类 匿名类 接口

抽象类:

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

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("电动门关闭");
    }
}

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


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

接口没有直接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();调用

接口可以多继承

演示

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 {

}

你可能感兴趣的:(抽象类 匿名类 接口)