抽象类(Abstract Class)和接口(Interface)的区别

一、抽象类(Abstract Class)

直接上代码！！

/**
 * @Description: 
 *      抽象类：使用 abstract 关键字修饰的类，叫作抽象类;只声明不实现。
 *      抽象方法：使用 abstract 关键字修饰的方法，叫作抽象方法
 * @Author: IT-Rain
 **/
[public] abstract class Door {
    [public/protected] abstract void open();
    [public/protected] abstract void close();
}

/**
 * @Description:
 *      1、抽象类中可以存在普通的属性
 *      2、抽象类中可以存在普通的方法
 * @Author: IT-Rain
 **/
public abstract class Animal {
    // 毛色 - 普通属性
    [public/protected/private] String coatColor;
    // 吃饭 - 普通方法
    [public/protected/private] void eat(){
        System.out.println("我爱干饭！");
    };
}

/**
 * @Description:
 * 		子类通过继承抽象类来实现其定义的抽象方法，并可以选择性地重写其他方法。
 * @Author: IT-Rain
 **/
public abstract class Animal {
    // 叫声 - 抽象方法
    abstract void sound();
    // 毛色 - 普通属性
    private String coatColor;
    // 吃饭 - 普通方法
    public/protected void eat(){
        System.out.println("我爱吃饭！");
    };

    public String getCoatColor() {
        return coatColor;
    }

    public void setCoatColor(String coatColor) {
        this.coatColor = coatColor;
    }
}

/**
 * @Description:
 * @Author: IT-Rain
 **/
public class Dog extends Animal{

    /**
     * 重写父类中抽象方法
     */
    @Override
    void sound() {
        System.out.println("我是二哈,嗷嗷叫！");
    }

    /**
     * 测试：
     */
    public static void main(String[] args) {
        Animal dog = new Dog();
        dog.sound();//输出: 我是二哈,嗷嗷叫！
        dog.setCoatColor("黑白毛儿");
        System.out.println("二哈的颜色：" + dog.getCoatColor());//输出：二哈的颜色：黑白毛儿
        dog.eat();//输出：我爱吃饭！
    }
}

重点来啦！！：
【1】抽象类：使用 abstract 关键字修饰的类，叫作抽象类;只声明不实现。
【2】抽象方法：使用 abstract 关键字修饰的方法，叫作抽象方法。
【3】抽象方法必须为public或者protected（因为如果为private，则不能被子类继承，子类便无法实现该方法），缺省情况下默认为public。
【4】抽象类不能用来创建对象；
【5】如果一个类继承于一个抽象类，则子类必须实现父类的抽象方法。如果子类没有实现父类的抽象方法，则必须将子类也定义为为abstract类。

二、接口(Interface)

/**
 * @Description: 动物接口
 * @Author: IT-Rain
 **/
public interface Animal {
    //定义公共变量
    public static final String FOOT = "动物有四只脚！";
    // 叫声
    public abstract void sleep();
    // 吃饭
    void eat();

}

/**
 * @Description: 动物子类 - Dog
 * @Author: IT-Rain
 **/
public class Dog implements Animal{

    @Override
    public void sleep() {
        System.out.println("狗狗也需要睡觉的！");
    }

    @Override
    public void eat() {
        System.out.println("狗狗也需要干饭的！");
    }
}

/**
 * @Description: 动物子类 - Cat
 * @Author: IT-Rain
 **/
public class Cat implements Animal{

    @Override
    public void sleep() {
        System.out.println("猫咪也需要睡觉的！");
    }

    @Override
    public void eat() {
        System.out.println("猫咪也需要干饭的！");
    }
}

/**
 * @Description: 测试类
 * @Author: IT-Rain
 **/
public static void main(String[] args) {
        Animal dog = new Dog();
        dog.eat();//输出：狗狗也需要干饭的！
        dog.sleep();//输出：狗狗也需要睡觉的！

        Animal cat = new Cat();
        cat.eat();//输出：猫咪也需要干饭的！
        cat.sleep();//输出：猫咪也需要睡觉的！
    }

重点来啦！！：
【1】接口中的方法只有声明，没有实现。所有方法默认是 public abstract 的，可以不写这两个关键字。
【2】接口中可以包含常量，这些常量默认是 public static final 的，可以不写这些关键字。
【3】类通过 implements 关键字实现接口，实现接口的类需要提供接口中所有方法的具体实现。
【4】接口支持多继承，一个类可以实现多个接口。这种特性使得 Java 的接口更灵活，能够在不同类之间共享行为模式。

三、抽象类(Abstract Class)和接口(Interface)的区别

	接口(Interface)	抽象类(Abstract)
定义和语法	（1）使用 interface 关键字定义，可以包含方法声明、常量等，方法默认是 public abstract 的，常量默认是 public static final 的，不能包含实例变量。（2）接口中的方法都是抽象的，没有方法体，实现接口的类必须提供方法的具体实现。	（1）使用 abstract 关键字定义类，可以包含抽象方法和非抽象方法，可以有实例变量。（2）抽象类可以有构造方法，可以有成员变量，方法可以有实现，也可以没有。
多继承支持	支持多继承，一个类可以实现多个接口，通过 implements 关键字来实现。	不支持多继承，一个类只能继承一个抽象类，通过 extends 关键字来继承。
设计用途和约束	（1）主要用于描述对象应该具有哪些行为，从而达到一种规范的效果。（2）用于实现多重继承、解耦系统组件、实现回调等。	（1）主要用于代码复用，提供一个模板或者基类，封装子类中通用的方法和属性。（2）用于共享代码和数据，可以定义一些通用的方法。
实现的方式	（1）实现接口的类需要提供接口中所有方法的具体实现。（2）接口更加灵活，能够在不同类之间共享行为模式。	（1）可以包含方法的实现，子类可以选择性地覆盖这些方法。（2）适合于一些通用逻辑的封装，提供一些默认的实现。
使用场景	（1）当多个不相关的类需要实现相同的行为时，可以使用接口来实现多态。（2）当设计层次结构时，希望通过约定而非继承来强制一组类具有特定的行为时，使用接口是一个好的选择。	（1）当想要在多个相关类之间共享代码或者数据时，可以使用抽象类。（2）当希望定义子类中通用的行为，而且这些行为在基类中已有部分实现时，使用抽象类比较合适。