27-抽象类 和 接口

抽象类是一个特殊的父类，其内部允许编写抽象方法

 

public class AbstractDemo {
    public static void main(String[] args){

        // 抽象类不能实例化
        // Animal animal = new Animal(); // error: Animal is abstract; cannot be instantiated
        Cat cat = new Cat();
        cat.eat();   // 猫吃鱼
        cat.sleep(); // 非抽象方法，动物睡觉

        Dog dog = new Dog();
        dog.eat();   // 狗吃肉
        cat.sleep(); // 非抽象方法，动物睡觉
    }
}

abstract class Animal{

    // 抽象类的构造方法，只是为了让子类通过super访问
    public Animal(){
        System.out.println("抽象类的构造方法");
    }

    // 抽象方法，只有方法的声明，没有方法体
    public abstract void eat();

    // 普通方法（非抽象方法），既有方法的声明，也有方法体，可以让子类继承到继续使用
    public void sleep(){
        System.out.println("非抽象方法，动物睡觉");
    }
}

class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

class Dog extends Animal{
    @Override
    public void eat() {
        System.out.println("狗吃肉");
    }
}

 

接口体现的思想是对规则的声明，Java中的接口更多体现的是对行为的抽象

1）接口的定义格式：

interface 接口名 {}

2）接口和类之间是实现关系，通过implements关键字来完成

class 类名 implements 接口名{}

实现类（接口的子类）：

1）重写所有抽象方法

2）将实现类变成抽象类

这里需要注意：接口不允许实例化

 

public class InterfaceDemo {
    public static void main(String[] args) {

        // 接口不能实例化
        // InterfaceA interfaceA = new InterfaceA(); // error: InterfaceA is abstract; cannot be instantiated

        // 接口的子类必须实现接口中所有的抽象方法
        InterfaceB interfaceB = new InterfaceB();
        interfaceB.methodA(); // 实现接口A的方法A
        interfaceB.methodB(); // 实现接口A的方法B
    }
}

interface InterfaceA{
    // 接口中的成员变量都是常量，所以必须赋值
    public static final int NUM = 10;

    // 接口中的成员方法都是抽象方法，所以必须实现
    public abstract void methodA();

    public abstract void methodB();
}

// 1. 第一种方法，接口的子类必须实现接口中所有的抽象方法
class InterfaceB implements InterfaceA{
    @Override
    public void methodA() {
        System.out.println("实现接口A的方法A");
    }

    @Override
    public void methodB() {
        System.out.println("实现接口A的方法B");
    }
}
// 2. 第二种方法，接口的子类可以是抽象类，不必实现接口中的抽象方法
abstract class InterfaceC implements InterfaceA{

}

 

 

public class InterfaceDemo2 {
    public static void main(String[] args){

        ABImpl ab = new ABImpl();
        ab.showA();
        ab.showB();

        CImpl c = new CImpl();
        c.showC();
    }
}

interface A{
    public abstract void showA();
}

interface B{
    public abstract void showB();
}

// 类和接口的关系：可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口
class ABImpl implements A,B{
    @Override
    public void showA() {
        System.out.println("ABImpl类的showA");
    }

    @Override
    public void showB() {
        System.out.println("ABImpl类的showB");
    }
}

// 接口和接口的关系：可以单继承，也可以多继承
interface C extends A,B{
    public abstract void showC();
}

class CImpl implements C{
    @Override
    public void showA() {
        System.out.println("CImpl类的showA");
    }

    @Override
    public void showB() {
        System.out.println("CImpl类的showB");
    }

    @Override
    public void showC() {
        System.out.println("CImpl类的showC");
    }
}