抽象类与接口

一、抽象类

（一）抽象类快速入门

当父类的一些方法不能确定时，可以用abstract关键字来修饰该方法，这个方法就是抽象方法，用abstract来修饰的类就是抽象类。

下面我们用代码演示如何把Animal做成抽象类，并让子类Cat来实现。

abstract class Animal{
    String name;
    int age;
    abstract public void cry();
}

（二）抽象类的介绍

1、用abstract关键字来修饰一个类时，这个类就叫抽象类

//格式
访问修饰符 abstract 类名{
}

2、用abstract关键字来修饰一个方法时，这个方法就是抽象方法

//格式
访问修饰符 abstract 返回类型 方法名(参数列表);//没有方法体

3、抽象类的价值更多作用是在于设计，是设计者设计好后，让子类继承并实现抽象类

4、抽象类，是考官比较爱问的知识点，在框架和设计模式中使用较多

（三）抽象类使用的注意事项和细节讨论

1、抽象类不能被实例化

public class AbstractDetail01 {
    public static void main(String[] args) {
        //抽象类，不能被实例化
        //new A();//错误用法
    }
}

2、抽象类不一定要包含abstract方法，即抽象类可以没有abstract方法

//抽象类不一定要包含abstract方法，即抽象类可以没有abstract方法，还可以有实现的方法。
abstract class A {
    public void hi() {
        System.out.println("hi");
    }
}

3、一旦类包含了abstract方法，则这个类必须声明为abstract

//一旦类包含了abstract方法,则这个类必须声明为abstract
//正确写法
abstract class B {
    public abstract void hi();
}
//错误写法
class B {
    public abstract void hi();
}

4、abstract只能修饰类和方法

//abstract 只能修饰类和方法，不能修饰属性和其它的
class C {
   //错误用法(使用abstract关键字修饰属性)
   public abstract int n1 = 1;
}

5、抽象类可以拥有任意成员（抽象类的本质还是一个类），比如：非抽象方法、构造器、静态属性等等

//抽象类的本质还是类，所以可以有类的各种成员
abstract class D {
    public int n1 = 10;//属性
    public static  String name = "巫";//静态属性
    public void hi() {//方法
        System.out.println("hi");
    }
    public abstract void hello();//抽象方法
    public static void ok() {//静态方法
        System.out.println("ok");
    }
}

6、抽象方法不能有主体（方法体），如图所示

7、如果一个类继承了一个抽象类，则它必须实现那个抽象类的所有抽象方法，除非它自己也声明为abstract类

//如果一个类继承了抽象类，则它必须实现抽象类的所有抽象方法，除非它自己也声明为abstract类
abstract class E {
    public abstract void hi();
}
abstract class F extends E {
	//这里由于子类没有实现父类的抽象方法所以必须用abstract修饰F
}
class G extends E {
    @Override
    public void hi() { 
      //这里相等于G子类实现了父类E的抽象方法，所谓实现方法，就是有方法体，所以不再用abstract修饰G
    }
}

8、抽象方法不能使用private、final 和 static 来修饰，因为这些关键字和重写是相违背的

//抽象方法不能使用private、final 和 static来修饰，因为这些关键字都是和重写相违背的
abstract class H {
    public /*这里不能使用private/final/static*/  abstract void hi();//抽象方法
}

二、接口

（一）接口的基本介绍

接口就是给出一些没有实现的方法，封装到一起，到某个类要使用的时候，在根据具体情况把这些方法写出来。

语法：

interface 接口名{
	属性；
	抽象方法；
}
class 类名 implements 接口{
	该类属性；
	该类方法；
	必须实现接口的抽象方法；
}

小结：接口是更加抽象的抽象的类，抽象类里的方法可以有方法体，接口里的所有方法都没有方法体（JDK7.0之前）。接口体现了程序设计的多态和高内聚低耦合的设计思想。
特别说明：JDK8.0开始，接口可以有静态方法，默认方法，也就是说接口中可以有方法的具体实现。

（二）接口使用的注意事项和细节讨论

1、接口不能实例化

public class InterfaceDetail01 {
    public static void main(String[] args) {
    	//错误写法，因为接口不能实例化
        new IA();
    }
}

2、接口中所有的方法是public方法，接口中的抽象方法，可以不用abstract修饰

interface IA{
	void a();//实际上是public abstract void a();
}

3、一个普通类实现接口，就必须将该接口的所有方法都实现

interface IA {
    void say();
    void hi();
}
class Cat implements IA{

    @Override
    public void say() {//实现了接口中的抽象方法say();

    }
    
    @Override
    public void hi() {//实现了接口中的抽象方法hi();

    }
}
//下面的写法则会报错
/*
class Cat implements IA{
}
*/

4、抽象类实现接口，可以不用实现接口的方法

interface IA {
    void say();
    void hi();
}
abstract class Tiger implements  IA {

}

5、接口中的属性，只能是 final 的，而且是 public static final 修饰符

interface IB {
    //接口中的属性,只能是final的，而且是 public static final 修饰符
    int n1 = 10; //等价 public static final int n1 = 10;
    void hi();
}

6、一个类同时可以实现多个接口（理解为接口是对于Java单继承机制的一种补充）

interface IB {
    int n1 = 10; 
    void hi();
}
interface IC {
    void say();
}
class Pig implements IB,IC {//Pig类同时实现了接口IB和IC
    @Override
    public void hi() {
    }
    @Override
    public void say() {
    }
}

7、接口中的属性的访问形式：接口名.属性名

public class InterfaceDetail02 {
    public static void main(String[] args) {
        //证明 接口中的属性,是 public static final
        System.out.println(IB.n1);//说明n1 就是static，用法就是接口名.属性名
        //下面这行代码会报错，因为n1是 final 的不能被修改
        n1 = 30;
    }
}
interface IB {
    int n1 = 10; //等价 public static final int n1 = 10;
    void hi();
}

8、接口不能继承其它的类，但是可以继承多个接口

//接口不能继承其它的类,但是可以继承多个别的接口
interface ID extends IB,IC {//继承的IB、IC必须是接口，不能是类名
}

9、接口的修饰符只能是 public 和默认，这点和类的修饰符是一样的

//下面两种写法是正确的
interface IE{}
public interface IF{}

//下面两种写法都是错误的
//protected interface IG{}
//private interface IH{}

（三）接口的多态特性

1、多态参数

在案例中 UsbInterface usb 既可以接收手机对象，又可以接收相机对象，就体现了接口多态（接口引用可以指向实现了接口的类的对象）

public class InterfacePolyParameter {
    public static void main(String[] args) {

        //接口的多态体现
        //接口类型的变量 if01 可以指向 实现了IF接口类的对象实例
        IF if01 = new Monster();
        if01 = new Car();

        //继承体现的多态
        //父类类型的变量 a 可以指向 继承AAA的子类的对象实例
        AAA a = new BBB();
        a = new CCC();
    }
}

interface IF {}
class Monster implements IF{}
class Car implements  IF{}

class AAA {

}
class BBB extends AAA {}
class CCC extends AAA {}

2、多态数组

演示一个案例：
给 Usb 数组中，存放 Phone 和 相机对象 ，Phone 类还有一个特有的方法 call() ，请遍历 Usb 数组，如果是 Phone 对象，除了调用 Usb 接口定义的方法外，还需要调用 Phone 特有方法 call() 。

public class InterfacePolyArr {
    public static void main(String[] args) {

        //多态数组 -> 接口类型数组
        Usb[] usbs = new Usb[2];
        usbs[0] = new Phone_();
        usbs[1] = new Camera_();
        /*
        给Usb数组中，存放 Phone  和  相机对象，Phone类还有一个特有的方法call（），
        请遍历Usb数组，如果是Phone对象，除了调用Usb 接口定义的方法外，
        还需要调用Phone 特有方法 call
         */
        for(int i = 0; i < usbs.length; i++) {
            usbs[i].work();//动态绑定..
            //和前面一样，我们仍然需要进行类型的向下转型
            if(usbs[i] instanceof Phone_) {//判断他的运行类型是 Phone_
                ((Phone_) usbs[i]).call();
            }
        }

    }
}

interface Usb{
    void work();
}
class Phone_ implements Usb {
    public void call() {
        System.out.println("手机可以打电话...");
    }

    @Override
    public void work() {
        System.out.println("手机工作中...");
    }
}
class Camera_ implements Usb {

    @Override
    public void work() {
        System.out.println("相机工作中...");
    }
}

3、接口的多态传递现象

下面用代码演示多态传递现象

/**
 * 演示多态传递现象
 */
public class InterfacePolyPass {
    public static void main(String[] args) {
        //接口类型的变量可以指向，实现了该接口的类的对象实例
        IG ig = new Teacher();
        //如果IG 继承了 IH 接口，而Teacher 类实现了 IG接口
        //那么，实际上就相当于 Teacher 类也实现了 IH接口.
        //这就是所谓的 接口多态传递现象.
        IH ih = new Teacher();
    }
}

interface IH {
    void hi();
}
interface IG extends IH{ }
class Teacher implements IG {
    @Override
    public void hi() {
    }
}

三、抽象类与接口的关系

1、接口和继承解决的问题不同
继承的价值主要在于：解决代码的复用性和可维护性。
接口的价值主要在于：设计，设计好各种规范（方法），让其它类去实现这些方法。

2、接口比继承更加灵活
接口比继承更加灵活，继承是满足 is - a 的关系，而接口只需要满足 like - a 的关系。

3、接口在一定程度上实现代码解耦[即：接口规范性 + 动态绑定机制]

4、抽象类和接口的应用场景不同

抽象类的应用场景：
（1）父类只知道其子类应该包含怎样的方法，不能准确知道这些子类如何实现这些方法的情况下，使用抽象类。
（2）从多个具有相同特征的类中抽象出一个抽象类，以这个抽象类作为子类的模板，从而避免了子类设计的随意性。

接口的应用场景：
（1）一般情况下，实现类和它的抽象类之前具有 “is-a” 的关系，但是如果我们想达到同样的目的，但是又不存在这种关系时，使用接口。
（2）由于 Java 中单继承的特性，导致一个类只能继承一个类，但是可以实现一个或多个接口，此时可以使用接口。

5、什么时候使用抽象类和接口：
（1）如果拥有一些方法并且想让它们有默认实现，则使用抽象类。
（2）如果想实现多重继承，那么必须使用接口。因为 Java 不支持多继承，子类不能继承多个类，但可以实现多个接口，因此可以使用接口。
（3）如果基本功能在不断改变，那么就需要使用抽象类。如果使用接口并不断需要改变基本功能，那么就需要改变所有实现了该接口的类。

四、抽象类与接口的区别

（一）语法层面上的区别

（二）设计层面上的区别

1、抽象类是对一种事物的抽象，即对类抽象，而接口是对行为的抽象。抽象类是对整个类整体进行抽象，包括属性、行为，但是接口却是对类局部（行为）进行抽象。举个简单的例子，飞机和鸟是不同类的事物，但是它们都有一个共性，就是都会飞。那么在设计的时候，可以将飞机设计为一个类 Airplane，将鸟设计为一个类 Bird，但是不能将 飞行 这个特性也设计为类，因此它只是一个行为特性，并不是对一类事物的抽象描述。此时可以将 飞行 设计为一个接口Fly，包含方法fly( )，然后Airplane和Bird分别根据自己的需要实现Fly这个接口。然后至于有不同种类的飞机，比如战斗机、民用飞机等直接继承Airplane即可，对于鸟也是类似的，不同种类的鸟直接继承Bird类即可。从这里可以看出，继承是一个 "是不是"的关系，而 接口 实现则是 "有没有"的关系。如果一个类继承了某个抽象类，则子类必定是抽象类的种类，而接口实现则是有没有、具备不具备的关系，比如鸟是否能飞（或者是否具备飞行这个特点），能飞行则可以实现这个接口，不能飞行就不实现这个接口。

2、设计层面不同，抽象类作为很多子类的父类，它是一种模板式设计。而接口是一种行为规范，它是一种辐射式设计。什么是模板式设计？最简单例子，大家都用过 ppt 里面的模板，如果用模板 A 设计了 ppt B 和 ppt C，ppt B 和 ppt C 公共的部分就是模板 A 了，如果它们的公共部分需要改动，则只需要改动模板 A 就可以了，不需要重新对 ppt B 和 ppt C 进行改动。而辐射式设计，比如某个电梯都装了某种报警器，一旦要更新报警器，就必须全部更新。也就是说对于抽象类，如果需要添加新的方法，可以直接在抽象类中添加具体的实现，子类可以不进行变更；而对于接口则不行，如果接口进行了变更，则所有实现这个接口的类都必须进行相应的改动。

下面看一个网上流传最广泛的例子：门和警报的例子：门都有 open() 和 close() 两个动作，此时我们可以定义通过抽象类和接口来定义这个抽象概念：

abstract class Door {
    public abstract void open();
    public abstract void close();
}

或者

interface Door {
    public abstract void open();
    public abstract void close();
}

但是现在如果我们需要门具有报警 的功能，那么该如何实现？下面提供两种思路：
（1）将这三个功能都放在抽象类里面，但是这样一来所有继承于这个抽象类的子类都具备了报警功能，但是有的门并不一定具备报警功能；
（2）将这三个功能都放在接口里面，需要用到报警功能的类就需要实现这个接口中的 open( ) 和 close( )，也许这个类根本就不具备 open( ) 和 close( ) 这两个功能，比如火灾报警器。

从这里可以看出， Door 的 open() 、close() 和 alarm() 根本就属于两个不同范畴内的行为，open() 和 close() 属于门本身固有的行为特性，而 alarm() 属于延伸的附加行为。因此最好的解决办法是单独将报警设计为一个接口，包含 alarm() 行为，Door 设计为单独的一个抽象类，包含 open 和 close 两种行为。再设计一个报警门继承 Door 类和实现 Alarm 接口。

interface Alram {
    void alarm();
}
 
abstract class Door {
    void open();
    void close();
}
 
class AlarmDoor extends Door implements Alarm {
    void oepn() {
      //....
    }
    void close() {
      //....
    }
    void alarm() {
      //....
    }
}