Java面向对象进阶篇（抽象类和接口）
一.抽象类
在某些情况下，父类知道其子类应该包含哪些方法，但是无法确定这些子类如何实现这些方法。这种有方法签名但是没有具体实现细节的方法就是抽象方法。有抽象方法的类只能被定义成抽象类，抽象方法和抽象类必须使用abstract修饰。抽象类里可以没有抽象方法。
1.1 抽象类和抽象方法
抽象类和抽象方法的规则如下：
1.抽象类和抽象方法都必须使用abstract修饰符修饰，抽象方法不能有方法体
2.抽象类不能被实例化，无法使用new关键字来调用抽象类的构造器创建抽象类的实例。即使这个抽象类里不包含抽象方法。
3.抽象类可以包含成员变量，方法（普通方法、抽象方法），构造器，初始化块，内部类（接口，枚举类）5中成分。抽象类的构造器不能用于创建实例，主要是用于被子类调用。
4.含有抽象方法的类（直接定义了一个抽象方法；继承了一个父类，没有完全实现父类包含的抽象方法；或实现一个接口，但没有完全实现接口包含的抽象方法）只能被定义成抽象类。
定义抽象方法只需在普通方法上加上abstract修饰符，并把普通方法的方法体全部去掉，并在方法后增加分号即可
定义抽象类只需在普通类上增加abstract修饰符即可。
抽象类不能用于创建实例，只能当作父类被其他子类继承。
package com.company2; abstract class Shape{ private String color; //定义一个计算周长的方法 public abstract double calPerimeter(); //定义一个返回形状的方法 public abstract String getType(); public Shape(String color) { this.color = color; } public Shape() { } public String getColor() { return color; } public void setColor(String color) { this.color = color; } } public class Triangle extends Shape{ private double a; private double b; private double c; public Triangle(String color, double a, double b, double c) { super(color); setSides(a,b,c); } public void setSides(double a, double b, double c) { if(a+b > c || a+c > b || b+c > a){ this.a = a; this.b = b; this.c = c; } System.out.println("三角形两边之和必须大于第三边"); } @Override public double calPerimeter() { return a+b+c; } @Override public String getType() { return "三角形"; } }
当使用abstract修饰类时，表明这个类只能被继承；当使用abstract修饰方法时，表明这个方法必须有子类提供实现（重写）。而final修饰的方法不能被重写，final修饰的类不能被继承。因此final
和abstract永远不能同时使用。static和abstract不能同时修饰某个方法，没有类抽象方法的说法，但可以同时修饰内部类。abstract也不能修饰变量和构造器。
利用抽象类和抽象方法的优势，可以更好地发挥多态的优势，使得程序更加灵活。
1.2 抽象类的作用
从语义的角度来看，抽象类是从多个具体类中抽象出来的父类，它具有更高层次的抽象，它体现的是一种模板模式的设计。抽象类作为多个子类的通用模板，子类在抽象类的基础上进行
拓展，改造，避免了子类设计的随意性。
抽象类的普通方法可依赖与抽象方法，抽象方法则推迟到子类中提供实现
package com.company2; abstract class Speedmeter { private double turnRate;//转速 public Speedmeter() { } //把返回车轮半径的方法定义成抽象方法 public abstract double getRadius(); public void setTurnRate(double turnRate){ this.turnRate = turnRate; } public double getSpeed() { return Math.PI*2*getRadius()*turnRate; } } public class CarSpeedmeter extends Speedmeter{ @Override public double getRadius() { return 0.28; } public static void main(String[] args) { CarSpeedmeter csm = new CarSpeedmeter(); csm.setTurnRate(15); System.out.println(csm.getSpeed()); } }
模板模式在面向对象的软件中很常用，其原理简单，实现也简单。下面是使用模板模式的一些简单规则：
1.抽象父类可以只定义需要使用的某些方法，把不能实现的部分抽象成抽象方法，留给其子类实现。
2.父类中可能包含需要调用其他系列方法的方法。这些被调用方法既可以由父类实现，也可以由子类实现。父类提供的方法只是定义了一个通用算法，其实现也许并不完全由自身实现，必须
依赖于其子类的帮助。
二. Java 8改进的接口（interface）
2.1 接口的概念
接口是多个相似类中抽象出来的一组公共行为规范，接口不提供任何实现，它体现的是规范和实现分离的哲学。
规范和实现分离正是接口的好处，它让软件系统各组件之间面向接口耦合，可以为软件系统提供很好的松耦合设计，从而降低个模块间的耦合，为系统提供更好的可拓展性和可维护性。
接口可以有多个直接父接口，但接口只能继承接口，不能继承类
2.2 接口的定义规则
1.由于接口定义的是一种规范，用interface跟class区分，因此接口里不能包含构造器和初始化块定义。接口里可以包含成员变量（只能是静态常量），方法（只能是抽象实例方法，类方法或
默认方法）， 内部类（内部接口，枚举）定义。
2.因为接口定义的是多个类共同的公共行为规范。因此接口的所有成员（包括常量，方法，内部类）都是public访问权限。只能指定public修饰符，也可以省略。
3.接口定义的成员变量只能在定义时指定默认值，默认使用public static final修饰符修饰。可以省略不写。
4.接口定义的方法只能是抽象方法，类方法和默认方法。类方法和默认方法都必须有方法实现（方法体）。
下面定义一个接口
package com.company2; public interface Output { //定义的成员变量只能是常量，默认public static final修饰 int MAX_CACHE_LINE = 50; //接口里定义的普通方法只能是public的抽象方法，没有方法体 void out(); void getData(String msg); //接口里定义的默认方法，需要使用default修饰，默认public修饰，有方法体 default void print(String... msgs) { for(String msg:msgs) { System.out.println(msg); } } default void test() { System.out.println("默认的test()方法"); } //接口里定义的类方法，需要使用static修饰，默认public修饰，有方法体 static String staticTest() { return "接口里的类方法"; } }
不同包下的另一个类访问接口里的成员变量。如下
package com.company; import com.company2.Output; public class OutputFIeldTest { public static void main(String[] args) { System.out.println(Output.MAX_CACHE_LINE); System.out.println(Output.staticTest()); } }
2.3 接口的继承
接口的继承和类继承不一样，接口完全支持多继承，即一个接口可以有多个直接父接口。和类继承相似，子接口拓展某个父接口，将会获得父接口里定义的所有抽象方法、常量
一个接口继承多个父接口时，多个父接口排在extends关键字之后，多个父接口之间以逗号隔开。
2.4 使用接口
接口的主要用途
1.定义变量，也可用于强制类型转换。接口声明引用类型变量
2.调用接口中定义的常量
3.被其他类实现
类可以使用implements关键字实现一个或多个接口，这也是Java为单继承灵活性不足所做的补充。实现接口与继承父类相似，一样可以获得所实现接口里定义的常量，方法。
一个类可以继承一个父类，并同时实现多个接口，implements部分必须在extends部分之后。
一个类实现了一个或多个接口之后，这个类必须完全实现这些接口里所定义的全部抽象方法（也就是重写这些抽象方法）；否则该类将保留从父接口那里继承得到的抽象方法，该类也必须
定义成抽象类。
一个类实现某个接口时，该类将会获得接口中定义的常量，方法等。因此可以把实现接口理解为一种特殊的继承，相当于实现类完全继承了一个彻底抽象的类。
接口不能显式继承任何类，但所有接口类型的引用变量都可以直接赋给Object类型的引用变量。
三. 接口和抽象类
3.1 接口与抽象类的相似特征
1.接口和抽象类都不能被实例化，用于被其他类实现和继承
2.接口和抽象类都包含抽象方法，实现接口和继承抽象类的普通子类都必须实现这些抽象方法
3.2 接口与抽象类的设计目的差别
接口作为系统与外界交互的窗口，接口体现的是一种规范。对于接口的实现者而言，接口规定了实现者必须向外提供哪些服务（以方法的形式）；对于接口的调用者而言，接口规定了调用者
可以调用哪些服务，以及如何调用这些服务（就是如何调用方法）。当一个程序中使用接口时，接口是多个模块间的耦合标准；在多个应用程序之间使用接口时，接口是多个程序之间的通讯标准。
从某种程度上来看，接口类似于整个系统的总纲，它制定了各模块应该遵循的标准，因此一个系统中的接口不应该经常改变。一但接口发生改变，其影响是辐射性的，导致系统中的大部分都需
要重写。
抽象类作为系统中多个子类的共同父类，它所体现的是一种模板式设计。抽象类作为多个子类的抽象父类，可以被当成系统实现过程中的中间产品，这个中间产品已经实现了系统的部分功能（那
些已经提供实现的方法），但这个产品依然不能当成最终产品，必须有进一步的改善。
3.3 接口与抽象类的用法差别
1.接口里只能包含抽象方法，静态方法，默认方法，不能为普通方法提供方法实现。抽象类则可以完全包含普通方法。
2.接口里只能定义静态常量，不能定义普通成员变量。抽象类里即可以定义静态常量，也可以定义普通成员变量。
3.接口里不包含构造器。抽象类里可以包含构造器，抽象类里的构造器并不是用于创建对象，而是让其子类调用这些构造器来完成属于抽象类的初始化操作。
4.接口里不能包含初始化块。抽象类则可以完全包含初始化块
5.一个类最多只能有一个直接父类，包括抽象类。但一个类可以直接实现多个接口，通过实现多个接口可以弥补Java单继承的不足。
四. 面向接口编程
很多软件架构设计理论都倡导面向接口编程来降低程序的耦合。下面介绍两种常用的场景来示范接口编程的优势
4.1 简单工厂模式
假设程序中有个Computer类需要组合一个输出设备。有两种选择，让Computer类组合一个Printer对象，或者让Computer类组合一个Output。
假设让Computer类组合一个Printer对象，假如有一天系统需要重构，需要BetterPrinter来代替Printer，这就需要打开Computer类源代码进行修改，假如系统中有100个类组合了Printer，甚至1000个、
10000个...，这是多么大的工作量啊
为了避免这个问题，工厂模式建议让Computer类组合一个Output类型的对象，将Computer类和Printer类完全分离。Computer对象实际组合的是Printer对象还是BetterPrinter对象，对Computer而言
完全透明。当Printer对象切换到BetterPrinter对象时，系统完全不受影响。
package com.company2; public interface Output { //定义的成员变量只能是常量，默认public static final修饰 int MAX_CACHE_LINE = 50; //接口里定义的普通方法只能是public的抽象方法，没有方法体 void out(); void getData(String msg); //接口里定义的默认方法，需要使用default修饰，默认public修饰，有方法体 default void print(String... msgs) { for(String msg:msgs) { System.out.println(msg); } } default void test() { System.out.println("默认的test()方法"); } //接口里定义的类方法，需要使用static修饰，默认public修饰，有方法体 static String staticTest() { return "接口里的类方法"; } }
Output接口定义了一系列打印行为
package com.company2; interface Product { int getProduceTime(); } public class Printer implements Output,Product { private String[] printData = new String[MAX_CACHE_LINE]; //用以记录当前需打印的作业数 private int dataNum = 0; @Override public void out() { //只要还有作业就继续打印 while (dataNum > 0) { System.out.println("告诉打印机正在打印" + printData[0]); //把作业队列整体前移一位，并将剩下的作业数减1 System.arraycopy(printData, 1, printData, 0, --dataNum); } } @Override public void getData(String msg) { if(dataNum >= MAX_CACHE_LINE) { System.out.println("输出队列已满，添加失败"); } else{ //把打印数据添加到队列里，已保存数据的数量加1 printData[dataNum++] = msg; } } @Override public int getProduceTime() { return 45; } }
Printer实现了Output接口
package com.company2; public class Computer { private Output out; public Computer(Output out) { this.out = out; } public void keyIn(String msg) { out.getData(msg); } public void print() { out.out(); } }
Computer类完全与Printer类分离，只是与Output接口耦合。Computer不再负责创建Outputer对象，系统提供一个Ouputer工厂来负责生产Output对象。
package com.company2; public class OutputFactory { public Output getOutput() { return new Printer(); } public static void main(String[] args) { OutputFactory of = new OutputFactory(); Computer c = new Computer(of.getOutput()); c.keyIn("轻量级Java EE企业应用实战"); c.keyIn("疯狂Java讲义"); c.print(); } }
在该OutputFactory类中包含了一个getOutput()方法，返回Output实现类的实例，该方法负责创建Output实例
package com.company2; public class BetterPrinter implements Output { private String[] printData = new String[MAX_CACHE_LINE*2]; private int dataNum = 0; @Override public void out() { while(dataNum>0) { System.out.println("告诉打印机正在打印"+printData[0]); System.arraycopy(printData,1,printData,0,--dataNum); } } @Override public void getData(String msg) { if(dataNum >= MAX_CACHE_LINE * 2) { System.out.println("输出队列已满，添加失败"); } else{ printData[dataNum++] = msg; } } }
BetterPrinter类也实现了Output接口，因此也可当成Output对象使用，只要把OutputFactory工厂类的getOutput()方法中的下划线部分改为如下代码
return new BetterPrinter();
4.2 命令模式
假设一个方法需要遍历某个数组的数组元素，但无法确定在遍历数组元素时如何处理这些元素，需要在调用该方法时指定具体的处理行为。
对于这样的一个需求，必须把处理行为作为参数传入该方法，这个“处理行为”用编程来实现就是一段代码。
可以考虑使用一个Command接口定义一个方法，用这个方法来封装“处理行为”，但这个方法没有方法体，因为现在还无法确定这个处理行为
public interface Command { void process(int[] target); }
需要创建一个数组的处理类，在这个处理类包含一个process方法，这个方法还无法确定处理数组的处理行为，所以定义该方法时使用了一个Command参数，这个Command参数负责
对数组的处理行为
public class ProcessArray { public void process(int[] target,Command cmd) { cmd.process(target); } }
通过Command接口，就实现了让ProcessArray类和具体“处理行为”的分离，程序使用Command接口代表了对数组的处理行为。Command接口也没提供真正的处理，只有等到需要
调用ProcessArray对象的process()方法时，才真正传入一个Command对象，才确定对数组的处理行为。
下面代码示范了对数组的两种处理方式
public class CommandTest { public static void main(String[] args) { ProcessArray pa = new ProcessArray(); int[] target = [3,-4,6,4]; //第一次处理数组，具体处理行为取决于PrintCommand pa.process(target,new PrintCommand()); //第二次处理数组，具体处理行为取决于AddCommand pa.process(target,new AddCommand()); } }
两次不同的处理行为通过PrintCommand类和AddCommand类提供
package com.company2; public class PrintCommand implements Command{ public void process(int[] target) { for(int tmp:target) { System.out.println("迭代输出数组的元素"+tmp); } } }
package com.company2; public class AddCommand implements Command{ public void process(int[] target) { int sum = 0; for(int tmp:target) { sum += tmp; } System.out.println("数组的元素总和为"+sum); } }
