总结很多很多的区别(持续更新)2.抽象类和接口的区别

一、抽象类
什么是抽象类呢?先放一段代码

abstract class Shape{
    //可以添加普通数据成员 或者方法
    public void func1(){
    }
    public abstract void draw();//抽象方法:没有具体实现的方法 如果加{}会报错
}

抽象类顾名思义就是包含有抽象方法的类,他也有如下的注意事项:
1.要用关键字abstract进行修饰;
2.在抽象类中 可以有普通类的所有属性;
3.和普通类不同的是包含抽象方法;
4.方法是抽象的类一定是要被abstract修饰;
5.不能被实例化 (new);
6.抽象类的主要作用就是用来被继承的;
7.正是因为抽象类就是用来被继承的 所以不能被final所修饰;
例如final abstract class shape是不可行的
8.抽象方法也不能是私有的或者是static的 (是会被重写的);
9.只要有一个类继承了抽象类 那么 必须要重写抽象类的方法;
10.如果这个类不想重写父类的抽象方法 可以在前面加abstract;
11.抽象方法是不能有具体的实现的,如果加了{}花括号会报错哦

在抽象类中也可以发生向上转型,例如在上面我们定义了一个shape类,我们在它的子类中重写draw方法,在主函数中定义了一个drawMap方法,当我们以传参的形式将shape的子类向上转型给shape,调用shape的draw方法就会放生运行时绑定,也就是所谓的多态.

class Cycle extends Shape {
    @Override
    public void draw() {
        System.out.println("这是一个圆!");
    }
}
class Rect extends Shape {
    @Override
    public void draw() {
        System.out.println("这是一个矩形!");
    }
}
class Flower extends Shape {
    @Override
    public void draw() {
        System.out.println("这是一朵花");
    }
}
public class Main {
    public static void drawMap(Shape shape){
        shape.draw();
    }
    public static void main(String[] args) {
        //抽象类也可以发生向上转型
        Shape shape1=new Cycle();
        Shape shape2=new Rect();
        Shape shape3=new Flower();
        drawMap(shape1);
        drawMap(shape2);
        drawMap(shape3);
    }
}

二、接口
接口是比抽象类更抽象的存在,先来段代码

interface Shape{
    int a=10;
    void draw();//不能有实现方法
    default void func(){

    }
}

关于接口的注意事项:
1.interface关键字修饰;
2.里面的数据成员必须是一个常量;

• 默认是public static final
• 就如上的代码中int a=10;之所以不报错,因为接口中默认她是静态的被final所修饰的

3.里面的成员方法是默认为 public abstract;
4.在接口当中不能定义一个已经实现的方法;
5.接口当中可以有实现的方法 但一定要被default修饰;
6.同样的接口也是不可以被实例化的;
7.接口也可以有多个抽象方法;
8.一个类和接口的关系是实现,一个类可以实现多个接口,这也解决了单继承的问题;
9.一定不能省略实现接口的类里面的public,接口里的成员属性和方法的修饰符是默认的,类里面不加就是包访问权限了;
10.实现了该接口 一定要实现接口的方法;
11.接口也可以像抽象类一样发生向上转型

关于接口的扩展知识:
1.接口和接口之间可以通过extends进行联系

interface A{
    void func1();
}
//接口B在A的功能上扩展
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() {

    }
}

接口和接口之间不可以互相实现,但是可以继承,可以理解为功能的扩展,那么如上代码,如果AA类实现接口C就要重写A,B,C接口中的方法.
2.一个类可以继承一个类的同时实现多个接口

class Animal {
    protected String name;
    public Animal(String name) {
        this.name = name;
    }
}
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 + "正在蹬腿游泳");
    }
}
public class Main {
    public static void walk(IRunning iRunning){
        iRunning.run();
    }
    public static void main(String[] args){
        Cat cat=new Cat("小花");
        walk(cat);
        Frog frog=new Frog("小蛙");
        walk(frog);
    }
}

在这里建议一般把一个抽象类或一个接口单独写一个类哦
三、总结区别抽象类和接口
相同:
1.抽象类和接口都不能被实例化;
2.如果要继承或实现时,要重写其抽象方法;
3.如果抽象类的子类不能重写父类所有的抽象方法，那么该子类只能是抽象类。一个类实现接口，如不能全部实现接口方法，那么该类也只能为抽象类;
4.如果当一个类继承了一个抽象类或接口,被继承的抽象类和接口也是继承了某抽象类和接口,那么当前类要实现所有全部的抽象方法;
5.抽象类和接口都可以没有抽象方法
不同:
1.概念上,抽象类是被继承,接口是被实现的;
2.抽象类中定义的成员变量是普通的成员变量,其状态由前加的修饰符决定,接口中定义的成员变量默认是public static final 公共静态的常量;
3.接口中写普通方法要被default修饰,抽象类不需要;
4.接口可继承接口，并可多继承接口，抽象类只能单继承

其他关于访问修饰限定符:
由于抽象类和接口都是被用来继承和实现的,不能用private修饰,接口不仅限定于子类,所以也不能用protected修饰,都可以用默认访问修饰限定符和public,内部类可以用protected修饰.