抽象类和接口

一.抽象类
抽象类：包含抽象方法的类，我们把它叫做抽象类
1.用关键字abstract进行修饰
2.在抽象类中可以有普通类的所有属性
3.和普通的类 不一样的地方就是 包含了抽象方法
4.和普通的类 不一样的地方就是 他不能够被实例化
5.抽象类的主要作用就是用来被继承的
6.抽象类是用来被继承的 不能被final所修饰
7.抽象方法也不能是私有的 或者是 static的
8.只要有一个类继承了这个抽象类 那么必须要重写抽像类的方法
9.如果这个类不想重写抽象类里面的抽象方法 那么此时这个类也可以设置为抽象类
代码举例：

abstract class Picture{
    public int a;
    public void func() {
        System.out.println("func()");
    }
    public abstract void Draw();//抽象方法：没有具体实现的方法

}

abstract class B extends Picture {

}
/*class C extends B{
    //这里必须要重写
}*/

class A extends Picture {
    @Override
    public void Draw() {

    }
}
class Tree extends Picture {
    @Override
    public void Draw() {
        System.out.println("这是一棵树！");
    }
}
class Stone extends Picture {
    @Override
    public void Draw() {
        System.out.println("这是一块石头!");
    }
}
class Flowers extends Picture {
    @Override
    public void Draw() {
        System.out.println("这是一朵花!");
    }
}
public class TestDemo {
    public static void drawMap(Picture picture) {
        picture.Draw();
    }
    public static void main(String[] args) {
        Picture picture1 = new Tree();
        Picture picture2 = new Stone();
        Picture picture3 = new Flowers();

        drawMap(picture1);
        drawMap(picture2);
        drawMap(picture3);
    }
}

二.接口
1.interface 关键字修饰
2.里面的数据成员必须是一个常量
3.里面的成员方法默认为：public abstract
4.在接口当中 不能定义一个已经实现的方法
5.JDK1.8新特性：接口当中可以有实现的方法 但是这个方法一定是被default修饰的
6.类和接口的关系： 实现一个接口 implements 可以实现多个接口
7. 解决了 Java当中 单继承的问题
8.实现该接口 一定要重写该接口的方法
9.接口仍然不能被实例化
10.实现该接口的重写方法的时候 不能省略public
11.接口是不能被接口实现的
12.接口和接口之间可以通过extends进行联系
13.一个接口可以extends多个接口
代码举例:

interface Picture {
    void draw();
    //public int a = 10;
    //default void func() {}

}

class Tree implements Picture {
    @Override
    public void draw() {
        System.out.println("这是一棵树！");
    }
}

class Flowers implements Picture {
    @Override
    public void draw() {
        System.out.println("这是一朵花!");
    }
}

class Stone implements Picture {
    @Override
    public void draw() {
        System.out.println("这是一块石头!");
    }
}

public class TestDemo {
    public static void drawMap(Picture picture) {
        picture.draw();
    }
    public static void main(String[] args) {
        Picture picture1 = new Tree();
        Picture picture2 = new Stone();
        Picture picture3 = new Flowers();

        drawMap(picture1);
        drawMap(picture2);
        drawMap(picture3);

    }
}

代码举例：

interface A {
   void func1();
}
interface B extends A{
    void func2();
}
interface C extends B {
    void func3();
}

class AA implements C {
    @Override
    public void func1() {

    }

    @Override
    public void func2() {

    }

    @Override
    public void func3() {

    }
}


class Animal {
    protected String name;
    public Animal(String name) {
        this.name = name;
    }
}

interface IFlying {
    void fly();
}
interface IRunning {
    void run();
}
interface ISwimming {
    void swim();
}

//一个类可以继承一个类 并且同时 实现多个接口
class Cat extends Animal implements IRunning {
    public Cat(String name) {
        super(name);
    }
    @Override
    public void run() {
        System.out.println(this.name + "正在用四条腿跑");
    }
}

class Frog extends Animal implements IRunning, ISwimming {
    public Frog(String name) {
        super(name);
    }
    @Override
    public void run() {
        System.out.println(this.name + "正在往前跳");
    }
    @Override
    public void swim() {
        System.out.println(this.name + "正在蹬腿游泳");
    }
}
class Robot implements IRunning{
    @Override
    public void run() {
        System.out.println("机器人会跑!");
    }
}

public class TestDemo {
    public static void walk(IRunning iRunning) {
        iRunning.run();
    }
    public static void swim(ISwimming iSwimming) {
        iSwimming.swim();
    }
    public static void main(String[] args) {
        Cat cat = new Cat("汤姆");
        walk(cat);
        Frog frog = new Frog("娃娃");
        walk(frog);
        swim(frog);
        Robot robot = new Robot();
        walk(robot);
    }
}

三.抽象类和接口的区别
1.子类使用：抽象类用extends关键字继承父类
接口用implements关键字实现接口
2.子类限制：一个子类只能继承一个抽象类
一个子类可以实现多个接口
3.关系：一个抽象类可以实现多个接口
接口不能继承抽象类 但是接口可以使用extends关键字继承多个父接口
4.结构组成：抽象类：普通类+抽象方法
接口：抽象方法+全局变量