详谈抽象类和接口

抽象类

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();
    }
}

抽象类的作用

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

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

接口

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));
    }
}

抽象类和接口的区别