面向对象（下）

抽象类

在某些情况下，某个父类只是知道其子类应该包含怎样的方法，但无法知道这些子类如何实现这些方法。使用抽象方法即可满足该要求：抽象方法只有方法签名，没有方法实现的方法。

抽象方法和抽象类

抽象方法和抽象类必须使用abstract修饰符来定义，有抽象方法的类只能被定义成抽象类，抽象类里可以没有抽象方法。

抽象方法和抽象类的规则如下：

1. 抽象类和抽象方法必须使用abstract修饰符来修饰，抽象方法不能有方法体。
2. 抽象类不能被实例化，无法使用new关键字来调用抽象类的构造器创建抽象类的实例，即使抽象类里不包含抽象方法，也不能实例化。
3. 抽象类可以包含成员变量、方法（普通方法和抽象方法都可以）、构造器、初始化块、内部类（接口、枚举）5种成分。抽象类的构造器不能用于创建实例，主要是用于被其子类调用。
4. 含有抽象方法的类（包括直接定义了一个抽象方法；或直接继承了一个抽象父类，但没有完全实现父类包含的抽象方法；或实现了一个接口，但没有完全实现接口包含的抽象方法三种情况）只能被定义成抽象类。

定义抽象方法只需在普通方法上增加abstract修饰符，并把普通方法的方法体（也就是方法后花括号括起来的部分）全部去掉，并在方法后增加分号即可。
定义抽象类只需在普通类上增加abstract修饰符即可。甚至一个普通类（没有包含抽象方法的类），增加abstract修饰符后也将变成抽象类。

抽象类不能用于创建实例，只能当做父类被其他子类继承。

当使用abstract修饰类时，表明这个类只能被继承，当使用abstract修饰方法时，表明这个方法必须由子类提供实现（即重写）。而fina修饰类不能被继承，final修饰的方法不能被重写，因此final和abstact不能同时使用。

注意：
abstract不能用于修饰成员变量，不能用于修饰局部变量，即没有抽象变量，没有抽象成员变量说法；abstract也不能用于修饰构造器，没有抽象构造器，抽象类里定义的构造器只能是普通构造器。

除此之外，当使用static修饰一个方法时，表明这个方法属于该类本身，即通过该类就可调用该方法，但如果该方法被定义成抽象方法，则将导致通过该类来调用该方法时出现错误（调用了一个没有方法体的方法肯定会引起错误）。因此static和abstract不能同时修饰某个方法，即没有所谓的类抽象方法。

注意：
static和abstract并不是绝对互斥的，static和abstract虽然不能同时修饰某个方法，但可以同时修饰内部类。

注意：
abstract关键字修饰的方法必须被子类重写才有意义，否则这个方法将永远不会有方法体，因此abstract方法不能定义为private访问权限，即private 和 abstract不能同时修饰方法。

抽象类的作用

抽象类不能创建实例，只能当成父类来继承。从语义的角度来看，抽象类是从多个具体类中抽象出来的父类，具有更高层次的抽象，从多个具有相同特征的类中抽象出来一个抽象类，以这个抽象类作为其子类的模板，从而避免了子类设计的随意性。

抽象类体现的就是一种模板模式的设计，抽象类作为多个子类的通用模板，子类在抽象类的基础上进行扩展、改造，但子类总体上会保留抽象类的行为方式。

如果编写一个抽象父类，父类提供了多个子类的通用方法，并把一个或多个方法留给子类实现，这就是一种模板模式，模板模式也是十分常见且简单的设计模式之一。

public abstract class SpeedMeter{    //转速    private double turnRate;    public SpeedMeter()    {    }    //把返回车轮半径的方法定义成抽象方法    public abstract double getRadius();    public void setTurnRate(double turnRate)    {        this.turnRate = turnRate;    }    //定义计算速度的通用算法    public double getSpeed()    {        //速度等于车轮半径 * 2 * PI * 转速        return java.lang.Math.PI * 2 * getRadius()*turnRate;    }}/*getSpeed()方法依赖于getRadius()方法的返回值。对于一个抽象的SpeedMeter类而言，它无法确定车轮半径，因此getRadius()方法必须推迟到其子类中实现。*/

public class CarSpeedMeter extends SpeedMeter{    public double getRadius()    {        return 0.28;    }    public static void main(String[] args)    {        CarSpeedMeter csm = new CarSpeedMeter();        csm.setTurnRate(15);        System.out.println(cms.getSpeed());    }}

SpeedMeter类里提供了速度表的通用算法，但一些具体的实现细节则推迟到子类中实现。这也是一种典型模板模式。

模板模式在面向对象的软件中很常用，其原理简单，实现也很简单。
下面是使用模板模式的一些简单规则。
①抽象父类可以只定义需要使用的某些方法，把不能实现的部分抽象成抽象方法，留给其子类去实现。

②父类中可能包含需要调用其他系列方法的方法，这些被调方法既可以由父类实现，也可由其子类实现。父类里提供的方法只是定义了一个通用算法，其实现也许并不完全由其自身实现，而必须依赖其子类的辅助。

接口

接口的概念

接口定义了一种规范，接口定义了某一批类所需要遵守的规范，接口不关心这些类的内部状态数据，也不关心这些类里方法的实现细节，它只规定这批类里必须提供某些方法，提供这些方法的类就可以满足实际需要。

Java 8中接口的定义

[修饰符] interface 接口名 extends 父接口1,父接口2...{    零到多个常量定义...    零到到多个抽象方法定义...    零到多个内部类、接口、枚举定义...    零到到多个默认方法或类方法定义...}

1. 修饰符可以是public或者省略，如果省略了public访问控制符，则默认采用包权限访问控制符，即只有在相同包结构下才可以访问该接口。
2. 接口名应该与类名采用相同的命名规则。
3. 一个接口可以有多个直接父接口，但接口只能继承接口，不能继承类。

由于接口定义的是一种规范，因此接口里不能包含构造器和初始化块定义。接口里可以包含成员变量（只能是静态常量）、方法（只能是抽象实例方法、类方法或默认方法）、内部类（包括内部接口、枚举）定义。

对比接口和类的定义方式，不难发现接口的成员比类里的成员少了两种，而且接口里成员变量只能是静态常量，接口里的方法只能是抽象方法、类方法或默认方法。

前面已经说过了，接口里定义的是多个类共同的公共行为规范，因此接口里的所有成员包括常量、方法、内部类和内部枚举都是public访问权限。定义接口成员时，可以省略访问控制修饰符，如果指定访问控制修饰符，则只能使用public访问控制修饰符。

对于接口里定义的静态常量而言，它们是接口相关的，因此系统会自动为这些成员变量增加static和final两个修饰符。也就是说，在接口中定义成员变量时，不管是否使用public static final修饰符，接口里的成员变量总是使用这三个修饰符来修饰。而且接口里没有构造器和初始化块，因此接口里定义的成员变量只能在定义时指定默认值。

/系统自动为接口里定义的成员变量增加public static final修饰符int MAX_SIZE = 50;public static final int MAX_SIZE = 50;

接口里定义的方法只能是抽象方法、类方法或默认方法，因此如果不是定义默认方法，系统将自动为普通方法增加abstract修饰符；定义接口里的普通方法时不管是否使用public abstract修饰符，接口里的普通方法总是使用public abstract来修饰。接口里的普通方法不能有方法实现（方法体）；但类方法、默认方法都必须由方法实现（方法体）。

注意：
接口里定义的内部类、内部接口、内部枚举类都默认采用public static两个修饰符，不管定义时是否指定这两个修饰符，系统都会自动使用public static对它们进行修饰。

public interface Output{    //接口里定义的成员变量只能是常量    int MAX_CACHE_LINE = 50;    //接口里定义的普通方法只能是public的抽象方法    void out();    void getData(String msg);    //在接口里定义默认方法，需要使用default修饰    default void print(String... msgs)    {        for(String msg : msgs)        {            System.out.println(msg);        }    }    //在接口中定义默认方法，需要使用default修饰    default void test()    {        System.out.println("默认的test()方法");    }    //在接口中定义类方法，需要使用static修饰    static String staticTest()    {        return "接口里的类方法";    }}

Java 8允许在接口里定义默认方法，默认方法必须使用default修饰，该方法不能使用static修饰，无论程序是否指定，默认方法总是使用public修饰——如果开发者没有指定public，系统会自动为默认方法添加public修饰符，由于默认方法并不没有static修饰，因此不能直接使用接口来调用默认方法，需要使用接口的实现类的实例来调用这些默认方法。

Java 8允许在接口中定义类方法，类方法必须使用static修饰，该方法不能使用default修饰，无论程序是否指定，类方法总是使用public修饰——如果没有指定public，系统会自动为类方法添加public修饰符。类方法可以直接使用接口来调用。

接口里的成员默认是使用public static final修饰的，因此即使另一个类处于不同包下，也可以通过接口来访问接口里的成员变量。

注意：
从某个角度来看，接口可被当成一个特殊的类，因此一个Java源文件里最多只能有一个public接口，如果一个Java源文件里定义了一个public接口，则该源文件的主文件名必须与该接口名相同。

接口的继承

接口完全支持多继承，即一个接口可以有多个直接父接口。
接口不能显式继承任何类。

interface interfaceC extends interfaceA , interfaceB{    int PROP_C = 7;    void testC();}

使用接口

接口不能用于创建实例，但接口可以用于声明引用类型变量。当使用接口来声明引用类型变量时，这个引用类型变量必须引用到其实现类的对象。除此之外，接口的主要用途就是被实现类实现。

归纳起来，接口主要有如下用途。

1. 定义变量，也可用于进行强制类型转换。
2. 调用接口中定义的变量。
3. 被其他类实现。

一个类可以实现一个或多个接口，继承使用extends关键字，实现则使用implements关键字。因为一个类可以实现多个接口，这也是Java为单继承灵活性不足所做的补充。类实现接口语法格式如下：

[修饰符]  class 类名 extends 父类 implements 接口1,接口2...{    类体部分}//implements部分必须放在extends部分之后。

实现接口与继承父类相似，一样可以获得所实现接口里定义的常量（成员变量）、方法（包括抽象方法和默认方法）。

一个类实现了一个或多个接口之后，这个类必须完全实现这些接口里所定义的全部抽象方法（也就是重写这些抽象方法）；否则，该类将保留从父接口那里继承到的抽象方法，该类也必须定义成抽象类。

接口不能显式继承任何类。但接口类型的引用变量可以直接赋给Object类型的引用变量，所以上面程序中可以把Product类型的变量直接赋给Object类型的变量，这是利用向上转型来实现的。因为编译器知道任何Java对象都必须是Object或其子类的实例，Product类型的对象也不例外（它必须是Product接口实现类的对象，该类肯定是Object的显式或隐式子类）。

接口和抽象类

接口和抽象类很像，它们都具有如下特征：
①接口和抽象类都不能被实例化，它们都位于继承树的顶端，用于被其他类实现和继承。

②接口和抽象类都可以包含抽象方法，实现接口或继承抽象类的普通类都必须实现这些抽象方法。

但接口和抽象类之间的差别非常大，这种差别主要体现在二者设计目的上。下面具体分析二者差别。

接口作为系统与外界交互的窗口，接口体现的是一种规范。对于接口的实现者而言，接口规定了实现者必须向外提供哪些服务（以方法的形式来提供）；对于接口的调用者而言，接口规定了调用者可以调用哪些服务，以及如何调用这些服务（就是如何来调用方法）。当在一个程序中使用接口时，接口是多个模块间的耦合标准，当在多个应用程序之间使用接口时，接口是多个程序之间的通信标准。

从某种程序来看，接口类似于整个系统的“总纲”，它指定了系统各模块之间应遵循的标准，因此一个系统中的接口不应该经常改变。一旦接口被改变，对整个系统甚至其他系统影响将是辐射式的。

抽象类则不一样，抽象类作为系统中多个子类的共同父类，它所体现的是一种模板式的设计。抽象类作为多个子类的抽象父类，可以被当成系统实现过程中的中间产品，这个中间产品已经实现的系统的部分功能（那些已经提供实现的方法），但这个产品依然不能当成最终产品，必须有更进一步的完善，这种完善可能有几种不同方式。

除此之外，接口和抽象类在用法上也存在如下差别。
①接口里只能包含抽象方法，不能为普通方法提供方法实现（默认方法可以提供方法实现）；抽象类则可以包含普通方法。

②接口里只能定义常量，不能定义普通成员变量；抽象类里则即可以定义普通成员变量，也可以定义静态常量。

③接口里不包含构造器；抽象类可以包含构造器，抽象类里的构造器并不是用于创建对象，而是让其子类调用这些构造器来完成属于抽象类的初始化操作。

④接口里不能包含初始化块；但抽象类则可以完全包含初始化块

⑤抽象类和普通类一样，只能继承一个父类，但不能继承接口；接口可继承多个父接口，但不能继承类。

⑤一个类只能有一个直接父类，包括抽象类；但一个类可以实现多个接口，通过实现多个接口可以弥补Java单继承的不足。