一.抽象类
在某些情况下，父类知道其子类应该包含哪些方法，但是无法确定这些子类如何实现这些方法。这种有方法签名但是没有具体实现细节的方法就是抽象方法。有抽象方法的类只能被定义成抽象类，抽象方法和抽象类必须使用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);
}
}