抽象类和接口

抽象

1. 包含抽象方法的类，抽象类。使用abstract关键字来修饰的

2. 抽象方法是不能够具体实现的

3. 在抽象方法中，可以定义和普通类相同的数据属性和方法

4. 抽象类不能实例化

5. 抽象类就是为了被继承的

6. 一个普通类继承了抽象类之后，一定要重写抽象类的抽象方法

7. 如果一个类继承了抽象类，又不想重写抽象方法，那么就把这个类也设置为抽象类；但是其子类还需要重写该抽象方法

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

class Cycle extends  Shape {

    @Override
    public void draw() {  //重写父类方法
        System.out.println("Cycle");
    }
}

class Flower extends  Shape{

    @Override
    public void draw() {
        System.out.println("Flower");
    }
}

public class TestDemo {
    public static void  drawMap(Shape shape){
        shape.draw(); //动态绑定
    }

    public static void main(String[] args) {  
        drawMap(new Cycle());  //向上转型
        drawMap(new Flower());
    }
}

接口：接口是对某一种功能或者行为的抽象

1. 接口当中的方法，一定是不能够具体实现的
2. 接口当中default修饰的方法才能够有具体实现
3. 接口当中的成员变量，默认都是public static final
4. 接口中的方法，默认都是public abstract
5. 接口不能实例化，只能实现 implements
6. 接口也可以向上转型和动态绑定

interface Shape{
    void draw();  //接口中的方法不用方法体，只声明
/*    default public void func(){

    }
    default  public void  func2() {

    }*/
}
class Cycle implements  Shape{

    @Override
    public void draw() {
        System.out.println("⭕");
    }
}
class Flower implements  Shape{

    @Override  //重写方法
    public void draw() {
        System.out.println("❀");
    }
}
public class TestDemo {
    public static void drawMap(Shape shape) {
    shape.draw();  //动态绑定
    }

    public static void main(String[] args) {
        Shape shape1 = new Cycle();  //向上转型
        shape1.draw();
        drawMap(shape1);
        Shape shape2 = new Flower();
        shape2.draw();
        drawMap(shape2);
    }
}

实现多个接口，达到多继承的效果

class frog extends  Animal implements  Swimming,Runing {
    public frog (String name ) {
        super(name);
    }

    @Override
    public void swim() {
        System.out.println(this.name + "frog swimming");
    }

    @Override
    public void run() {
        System.out.println(this.name + "frog runing");
    }
}

class duck extends Animal implements Swimming,Runing,Flying{
    public duck(String name) {
        super(name);
    }
    @Override
    public void run() {
        System.out.println(this.name + "duck runing");
    }

    @Override
    public void swim() {
        System.out.println(this.name + "duck swimming");
    }

    @Override
    public void fly() {
        System.out.println(this.name + "duck flying");
    }
}

  public static void swim(Swimming swimming) {
        swimming.swim();
    }
    public static void run(Runing runing) {
        runing.run();
    }
    public static void main(String[] args) {
       frog frog= new frog("frog");
       swim(frog);
       run(frog);
    }

意义：

1. 实现多继承
2. 可扩展性非常强

注意：接口可以extends接口，即接口的扩展 ,接口也可以extends多个接口

抽象类和接口的区别：

• 抽象类可以有构造方法，接口中不能有构造方法。
• 抽象类中可以有普通成员变量，接口中没有普通成员变量
• 抽象类中可以包含非抽象的普通方法，接口中的所有方法必须都是抽象的，不能有非抽象的普通方法。
• 抽象类中的抽象方法的访问类型可以是public，protected，但接口中的抽象方法只能是public类型的，并且默认即为public abstract类型。
• 抽象类中可以包含静态方法，接口中不能包含静态方法
• 抽象类和接口中都可以包含静态成员变量，抽象类中的静态成员变量的访问类型可以任意，但接口中定义的变量默认为public static final类型。
• 一个类可以实现多个接口，但只能继承一个抽象类。