第3章 面向对象 - 抽象类与接口
1. 抽象类
当定义一个类时，常常需要定义一些方法来描述该类的行为特征，但有时这些方法的实现方式是无法确定的。例如前面在定义Animal类时，shout()方法用于表示动物的叫声，但是针对不同的动物，叫声也是不同的，因此在shout()方法中无法准确描述动物的叫声。
针对上面描述的情况，Java允许在定义方法时不写方法体，不包含方法体的方法为抽象方法，抽象方法必须使用abstract关键字来修饰。
抽象类概述
抽象定义：抽象就是从多个事物中将共性的、本质的内容抽取出来。例如：狼和狗共性都是犬科，犬科就是抽象出来的概念。
抽象类：Java中可以定义没有方法体的方法，该方法的具体实现由子类完成，该方法称为抽象方法，包含抽象方法的类就是抽象类。
抽象方法的由来：多个对象都具备相同的功能，但是功能具体内容有所不同，那么在抽取过程中，只抽取了功能定义，并未抽取功能主体，那么只有功能声明，没有功能主体的方法称为抽象方法。
例如：狼和狗都有吼叫的方法，可是吼叫内容是不一样的。所以抽象出来的犬科虽然有吼叫功能，但是并不明确吼叫的细节。
抽象类实际上是定义了一个标准和规范，等着他的子类们去实现。
抽象类的特点
抽象类不能创建实例，只能当成父类来被继承。抽象类是从多个具体类中抽象出来的父类，它具有更高层次的抽象。
抽象类体现的就是一种模板模式的设计，抽象类作为多个子类的通用模板。
当一个类中包含了抽象方法，该类必须使用abstract关键字来修饰，使用abstract关键字修饰的类为抽象类。
在定义抽象类时需要注意，包含抽象方法的类必须声明为抽象类，但抽象类可以不包含任何抽象方法，只需使用abstract关键字来修饰即可。另外，抽象类是不可以被实例化的，因为抽象类中有可能包含抽象方法，抽象方法是没有方法体的，不可以被调用。如果想调用抽象类中定义的方法，则需要创建一个子类，在子类中将抽象类中的抽象方法进行实现。
抽象类和抽象方法必须用abstract关键字来修饰。
抽象方法只有方法声明，没有方法体，定义在抽象类中。
格式：修饰符 abstract 返回值类型 函数名(参数列表) ;
抽象类不可以被实例化，也就是不可以用new创建对象。
原因如下：
抽象类是具体事物抽取出来的，本身是不具体的，没有对应的实例。例如：犬科是一个抽象的概念，真正存在的是狼和狗。
而且抽象类即使创建了对象，调用抽象方法也没有意义。
抽象类通过其子类实例化，而子类需要覆盖掉抽象类中所有的抽象方法后才可以创建对象，否则该子类也是抽象类。
示例：
abstract class Demo{abstract /*抽象*/ void show();}class DemoA extends Demo{void show(){System.out.println("demoa show" );}}class DemoB extends Demo{void show(){System.out.println("demob show" );}}class AbstractDemo{public static void main(String[] args){DemoA demoA = new DemoA();demoA.show();DemoB demoB = new DemoB();demoB.show();}}
运行结果：
抽象类举例代码讲解
需求：公司中程序员有姓名，工号，薪水，工作内容。项目经理除了有姓名，工号，薪水，还有奖金，工作内容。
分析：在这个问题领域中，通过名词提炼法：
程序员：
属性：姓名，工号，薪水。
行为：工作。
经理：
属性：姓名，工号，薪水，奖金。
行为：工作。
程序员和经理不存在着直接继承关系。但是，程序员和经理却具有共性内容，可以进行抽取，因为他们都是公司的雇员。可以将程序员和经理进行抽取，建立体系。
代码：
//描述雇员。abstract class Employee{private String name ;private String id ;private double pay ;Employee(String name,String id, double pay){this.name = name;this.id = id;this.pay = pay;}public abstract void work();}//描述程序员class Programmer extends Employee{Programmer(String name,String id, double pay){super(name,id,pay);}public void work(){System.out.println("code..." );}}//描述经理class Manager extends Employee{private int bonus ;Manager(String name,String id, double pay,int bonus){super(name,id,pay);this.bonus = bonus;}public void work(){System.out.println("manage" );}}
抽象类相关问题
抽象类中是否有构造函数？
答：有，用于给子类对象进行初始化。
抽象关键字abstract不可以和哪些关键字共存？
答：private、static、final。
抽象类中可不可以没有抽象方法？
答：可以，但是很少见。目的就是不让该类创建对象，AWT的适配器对象就是这种类。通常这个类中的方法有方法体，但是却没有内容。
示例：
abstract class Demo{void show1(){}void show2(){}}
抽象类和一般类的区别？
相同点：抽象类和一般类都是用来描述事物的，都在内部定义了成员。
不同点：
- 一般类有足够的信息描述事物。抽象类描述事物的信息有可能不足。
- 一般类中不能定义抽象方法，只能定义非抽象方法。抽象类中可定义抽象方法，同时也可以定义非抽象方法。
- 一般类可以被实例化。抽象类不可以被实例化。
抽象类一定是个父类吗？
答：是的，因为需要子类覆盖其方法后才可以对子类实例化。
2. 接口
当一个抽象类中的方法都是抽象的时候，这时可以将该抽象类用另一种形式定义和表示，就是接口。
格式：interface {}
接口中的成员修饰符是固定的：
成员常量：public static final
成员函数：public abstract
由此得出结论，接口中的成员都是公共的权限
接口是对外暴露的规则
接口是程序的功能扩展
注意事项：
- 虽然抽象类中的全局变量和抽象方法的修饰符都可以不用写，但是这样阅读性很差。所以，最好写上
- 类与类之间是继承关系，类与接口直接是实现关系
- 接口不可以实例化，能由实现了接口并覆盖了接口中所有的抽象方法的子类实例化。否则，这个子类就是一个抽象类。
通常所说的接口
- 接口还可以是对外提供的服务，你封装好的类库供人调用，这也可以理解为接口
- 程序接口应该是你公布出来供别人调用使用的类和方法
- 接口一般指的是HTTP接口，也可以说是HTTP API
- 接口由后端提供，前端调用后端接口以获取后端数据
- 接口由URL和HTTP方法构成，URL为接口的地址，HTTP方法指的是GET, PUT, DELETE等
示例：
interface Demo{public static final int NUM = 4;public abstract void show1();public abstract void show2();}class DemoImpl implements /*实现*/Demo{public void show1(){}public void show2(){}}class InterfaceDemo{public static void main(String[] args){DemoImpl d = new DemoImpl();System.out.println(d.NUM);System.out.println(DemoImpl.NUM);System.out.println(Demo.NUM);}}
运行结果：
接口的出现将“多继承”通过另一种形式体现出来，即“多实现”。
在java中不直接支持多继承，因为会出现调用的不确定性。
所以，java将多继承机制进行改良，在java中变成了多实现，一个类可以实现多个接口。
接口的出现避免了单继承的局限性。
示例：
interface A{public void show();}interface Z{public void show();}//多实现class Test implements A,Z{public void show(){System.out.println("Test");}}class InterfaceDemo{public static void main(String[] args){Test t = new Test();t.show();}}
运行结果：
一个类在继承另一个类的同时，还可以实现多个接口。
示例1：
interface A{public void show();}interface Z{public void show();}class Q{public void method(){}}abstract class Test2 extends Q implements A,Z{}
示例2：
interface CC{void show();}interface MM{void method();}//接口与接口之间是继承关系，而且接口可以多继承interface QQ extends CC,MM{public void function();}class WW implements QQ{//覆盖3个方法public void show(){}public void method(){}public void function(){}}
抽象类和接口的异同点？
相同点：都是不断向上抽取而来的。
不同点：
- 抽象类需要被继承，而且只能单继承。接口需要被实现，而且可以多实现。
- 抽象类中可以定义抽象方法和非抽象方法，子类继承后，可以直接使用非抽象方法。接口中只能定义抽象方法，必须由子类去实现。
- 抽象类的继承，是is a关系，定义该体系的基本共性内容。接口的实现是like a关系
接口应用综合案例
代码：
/*笔记本电脑使用。为了扩展笔记本的功能，但日后出现什么功能设备不知道。因此需要定义一个规则，只要日后出现的设备都符合这个规则就可以了。规则在java中就是接口。*/interface USB{//暴露的原则public void open();public void close();}//实现原则//这些设备和电脑的耦合性降低了class UPan implements USB{public void open(){System.out.println("upan open");}public void close(){System.out.println("upan close");}}class UsbMouse implements USB{public void open(){System.out.println("usbMouse open");}public void close(){System.out.println("usbMouse close");}}class BookPC{public static void main(String[] args){//功能扩展了useUSB(new UPan());}//使用原则public static void useUSB(USB u){//接口类型的引用，用于接收（指向）接口的子类对象if(u != null ){u.open();u.close();}}}
运行结果：
Java8改进的接口
Java 8 对接口进行了改进，允许在接口中定义默认方法，默认方法可以提供方法实现。
3. 深入理解Java的接口和抽象类
对于面向对象编程来说，抽象是它的一大特征之一。在Java中，可以通过两种形式来体现OOP的抽象：接口和抽象类。这两者有太多相似的地方，又有太多不同的地方。很多人在初学的时候会以为它们可以随意互换使用，但是实际则不然。今天我们就一起来学习一下Java中的接口和抽象类。
抽象类
在了解抽象类之前，先来了解一下抽象方法。抽象方法是一种特殊的方法：它只有声明，而没有具体的实现。抽象方法的声明格式为：abstract void fun();
抽象方法必须用abstract关键字进行修饰。如果一个类含有抽象方法，则称这个类为抽象类，抽象类必须在类前用abstract关键字修饰。因为抽象类中含有无具体实现的方法，所以不能用抽象类创建对象。
下面要注意一个问题：在《Java编程思想》一书中，将抽象类定义为“包含抽象方法的类”，但是后面发现如果一个类不包含抽象方法，只是用abstract修饰的话也是抽象类。也就是说抽象类不一定必须含有抽象方法。个人觉得这个属于钻牛角尖的问题吧，因为如果一个抽象类不包含任何抽象方法，为何还要设计为抽象类？所以暂且记住这个概念吧，不必去深究为什么。
public abstract class ClassName {abstract void fun();}
从这里可以看出，抽象类就是为了继承而存在的，如果你定义了一个抽象类，却不去继承它，那么等于白白创建了这个抽象类，因为你不能用它来做任何事情。对于一个父类，如果它的某个方法在父类中实现出来没有任何意义，必须根据子类的实际需求来进行不同的实现，那么就可以将这个方法声明为abstract方法，此时这个类也就成为abstract类了。
包含抽象方法的类称为抽象类，但并不意味着抽象类中只能有抽象方法，它和普通类一样，同样可以拥有成员变量和普通的成员方法。注意，抽象类和普通类的主要有三点区别：
抽象方法必须为public或者protected（因为如果为private，则不能被子类继承，子类便无法实现该方法），缺省情况下默认为public
抽象类不能用来创建对象
如果一个类继承于一个抽象类，则子类必须实现父类的抽象方法。如果子类没有实现父类的抽象方法，则必须将子类也定义为为abstract类
在其他方面，抽象类和普通的类并没有区别。
接口
接口，英文称作interface，在软件工程中，接口泛指供别人调用的方法或者函数。从这里，我们可以体会到Java语言设计者的初衷，它是对行为的抽象。在Java中，定一个接口的形式如下：
public interface InterfaceName {}
接口中可以含有 变量和方法。但是要注意，接口中的变量会被隐式地指定为public static final变量（并且只能是public static final变量，用private修饰会报编译错误），而方法会被隐式地指定为public abstract方法且只能是public abstract方法（用其他关键字，比如private、protected、static、 final等修饰会报编译错误），并且接口中所有的方法不能有具体的实现，也就是说，接口中的方法必须都是抽象方法。从这里可以隐约看出接口和抽象类的区别，接口是一种极度抽象的类型，它比抽象类更加“抽象”，并且一般情况下不在接口中定义变量。
要让一个类遵循某组特地的接口需要使用implements关键字，具体格式如下：
class ClassName implements Interface1,Interface2,[....]{}
可以看出，允许一个类遵循多个特定的接口。如果一个非抽象类遵循了某个接口，就必须实现该接口中的所有方法。对于遵循某个接口的抽象类，可以不实现该接口中的抽象方法。
接口定义了一种规范，接口定义了某一批类所需要遵守的规范，接口不关心这些类的内部状态数据，也不关心这些类的内部方法的实现细节，它只规定这批类里必须提供某些方法，提供这些方法的类就可满足实际需要。
接口体现的是规范和实现分离的设计哲学。让规范和实现分离正是接口的好处，让软件系统的各组件之间面向接口耦合，是一种松耦合的设计。
类似的，软件系统的各模块之间也应该采用这种面向接口的耦合，从而尽量降低各模块之间的耦合，为系统提供更好的可扩展性和可维护性。
抽象类和接口的区别
1.语法层面上的区别
抽象类可以提供成员方法的实现细节，而接口中只能存在public abstract 方法；
抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是public static final类型的；
接口中不能含有静态代码块以及静态方法，而抽象类可以有静态代码块和静态方法；
一个类只能继承一个抽象类，而一个类却可以实现多个接口。
2.设计层面上的区别
接口是事物的能力，直接理解就是约定；抽象类是事物的本质。
抽象类是对一种事物的抽象，即对类抽象，而接口是对行为的抽象。抽象类是对整个类整体进行抽象，包括属性、行为，但是接口却是对类局部（行为）进行抽象。
继承是 is a的关系，而 接口实现则是 has a 的关系。如果一个类继承了某个抽象类，则子类必定是抽象类的种类，而接口实现就不需要有这层类型关系。
设计层面不同，抽象类作为很多子类的父类，它是一种模板式设计。而接口是一种行为规范，它是一种辐射式设计。也就是说：
- 对于抽象类，如果需要添加新的方法，可以直接在抽象类中添加具体的实现，子类可以不进行变更；
- 而对于接口则不行，如果接口进行了变更，则所有实现这个接口的类都必须进行相应的改动。
抽象类是对一种事物的抽象，即对类抽象，而接口是对行为的抽象。抽象类是对整个类整体进行抽象，包括属性、行为，但是接口却是对类局部（行为）进行抽象。举个简单的例子，飞机和鸟是不同类的事物，但是它们都有一个共性，就是都会飞。那么在设计的时候，可以将飞机设计为一个类Airplane，将鸟设计为一个类Bird，但是不能将 飞行 这个特性也设计为类，因此它只是一个行为特性，并不是对一类事物的抽象描述。此时可以将 飞行 设计为一个接口Fly，包含方法fly( )，然后Airplane和Bird分别根据自己的需要实现Fly这个接口。然后至于有不同种类的飞机，比如战斗机、民用飞机等直接继承Airplane即可，对于鸟也是类似的，不同种类的鸟直接继承Bird类即可。从这里可以看出，继承是一个 “是不是”的关系，而 接口 实现则是 “有没有”的关系。如果一个类继承了某个抽象类，则子类必定是抽象类的种类，而接口实现则是有没有、具备不具备的关系，比如鸟是否能飞（或者是否具备飞行这个特点），能飞行则可以实现这个接口，不能飞行就不实现这个接口。
设计层面不同，抽象类作为很多子类的父类，它是一种模板式设计。而接口是一种行为规范，它是一种辐射式设计。什么是模板式设计？最简单例子，大家都用过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();}
但是现在如果我们需要门具有报警alarm( )的功能，那么该如何实现？下面提供两种思路：
将这三个功能都放在抽象类里面，但是这样一来所有继承于这个抽象类的子类都具备了报警功能，但是有的门并不一定具备报警功能；
将这三个功能都放在接口里面，需要用到报警功能的类就需要实现这个接口中的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() {//....}}
3.实际应用上的差异
在实际使用中，使用抽象类(也就是继承)，是一种强耦合的设计，用来描述A is a B 的关系，即如果说A继承于B，那么在代码中将A当做B去使用应该完全没有问题。比如在Android中，各种控件都可以被当做View去处理。
如果在你设计中有两个类型的关系并不是is a，而是is like a，那就必须慎重考虑继承。因为一旦我们使用了继承，就要小心处理好子类跟父类的耦合依赖关系。组合优于继承。
继承和实现接口的区别就是：继承描述的是这个类『是什么』的问题，而实现的接口则描述的是这个类『能做什么』的问题。
抽象类
- 体现的是 is a 关系，即继承关系，抽象类是多个具体类的抽象，是用来被继承的。
- 体现的是一种模板模式的设计
接口
- 定义的是一种规范，体现的是一种规范和实现分离的哲学
- 对Java单继承的补充，是一种功能增强
- 接口回调，一种消息通信机制
- 面向接口编程，解耦
- 接口无法保存状态