详谈抽象类和接口

抽象类

1.使用abstract修饰类

2.抽象类中，可以包含普通类所能包含的成员

3.抽象类和普通类的区别在于，抽象类当中可以包含抽象方法，抽象类中也可以不包含抽象方法

4.抽象方法是使用abstract修饰的，这个方法没有具体的实现

5.不能实例化抽象类 → new

6.抽象类存在的最大意义就是为了被继承

7.如果一个普通类继承了一个抽象类，此时必须重写抽象类当中的方法

8.如果一个抽象类A继承了抽象类B，此时A当中不需要重写B的抽象方法，但如多A再被普通类继承那么就要重写

9.抽象方法不能是私有的，即满足重写的规则；也不能被static和final修饰

10.抽象类当中可以有构造方法。这是为了方便子类能够调用，从而初始化抽象类中的成员

abstract class Shape {
    //抽象方法
    public abstract void draw();
}
/*
abstract class A extends Shape {

}
class B extends A {
    @Override
    public void draw() {
        System.out.println("dsfsasa");
    }
}
*/

class Rect extends Shape {
    @Override
    public void draw() {
        System.out.println("矩形！");
    }
}

class Cycle extends Shape {
    @Override
    public void draw() {
        System.out.println("画圆！");
    }
}

class Triangle extends Shape {
    @Override
    public void draw() {
        System.out.println("画一个三角形！");
    }
}

class Flower extends Shape {
    @Override
    public void draw() {
        System.out.println("?！");
    }
}

public class Test {
    public static void drawMap(Shape shape) {
        shape.draw();
    }
    public static void main(String[] args) {
        Rect rect = new Rect();
        drawMap(rect);
        drawMap(new Cycle());
        drawMap(new Triangle());
        drawMap(new Flower());
    }

    public static void main1(String[] args) {
        //Shape shape = new Shape();
        Shape shape = new Rect();
    }
}

抽象类的作用

? ? ? ? 使用抽象类的场景就如上面的代码, 实际工作不应该由父类完成, 而应由子类完成. ?那么此时如果不小心误用成父类了, 使用普通类编译器是不会报错的. 但是父类是抽象类就会在实例化的时候提示错误, 让我们尽早发现问题.

? ? ? ? 例如我们曾经用过的 ?nal 也是类似. 创建的变量用户不去修改, 不就相当于常量嘛? 但是加上 ?nal 能够在不小心误修改的时候, 让编译器及时提醒我们.充分利用编译器的校验, 在实际开发中是非常有意义的.

接口

1.使用interface来修饰 接口

2.接口当中的成员方法，不能有具体的实现。

? ? ? ?抽象方法：默认是public abstract的方法

? ? ? ?从JDK1.8开始，允许有可以实现的方法，但是这个方法只能是由default修饰的

? ? ? ?可以实现有一个静态方法。

3.成员变量默认是public static final 修饰的

4.?接口不能被实例化

5.类和接口之间采用implements 来实现多个接口

6.子类重写抽象方法，必须加上public

7.接口中不能有静态代码块和构造方法

8.如果你不想实现接口的方法，那么就把这个类定义为抽象类。但是如果这个类被其他类继承 那么必须重写

9.一个类可以实现多个接口。 使用 implements 用逗号隔开[可以解决多继承的问题]

interface IFLying {
    void flying();
}

interface ISwimming {
    void swimming();
}

interface IRunning {
    void running();
}

class Animals {
    public String name;
    public int age;

    public Animals(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void eat() {
        System.out.println("吃饭！");
    }
}

class Dogs extends Animals implements IRunning,ISwimming {

    public Dogs(String name, int age) {
        super(name,age);
    }

    @Override
    public void swimming() {
        System.out.println(name + " 正在游泳！");
    }

    @Override
    public void running() {
        System.out.println(name + " 正在跑！");
    }

    @Override
    public void eat() {
        System.out.println(name+"正在吃狗粮！");
    }
}

class Bird extends Animals implements IFLying {

    public Bird(String name, int age) {
        super(name, age);
    }

    @Override
    public void flying() {
        System.out.println(name + "正在飞！");
    }
    @Override
    public void eat() {
        System.out.println(name+"正在鸟粮！");
    }
}

//在Java中，类和类之间是单继承的，一个类可以实现多个接口，接口与接口之间可以多继承。  即：用接口可以达到多继承的目的。
class Duck extends Animals implements IFLying,IRunning,ISwimming {

    public Duck(String name, int age) {
        super(name, age);
    }

    @Override
    public void flying() {
        System.out.println(name + "正在飞！");
    }

    @Override
    public void swimming() {
        System.out.println(name + " 正在游泳！");
    }

    @Override
    public void running() {
        System.out.println(name + " 正在跑！");
    }

    @Override
    public void eat() {
        System.out.println(name+"正在吃鸭粮！");
    }
}

class Roobot implements IRunning {
    @Override
    public void running() {
        System.out.println("机器人正在跑！");
    }
}

public class Test5 {

    //在这个 walk 方法内部, 我们并不关注到底是哪种动物, 只要参数是会跑的, 就行
    //甚至参数可以不是 "动物", 只要会跑!
    public static void walk(IRunning iRunning) {
        iRunning.running();
    }

    public static void func(Animals animals) {
        animals.eat();
    }

    public static void main(String[] args) {
        walk(new Dogs("hello",10));
        walk(new Duck("hello1",20));
        walk(new Roobot());
        System.out.println("=====================");
        func(new Dogs("hello",10));
        func(new Duck("hello1",20));
    }
}

抽象类和接口的区别