13. 抽象类 & 接口
一、抽象类
// 抽象类Shape
public abstract class Shape
{
// 1. 成员变量
private String color;
// 2. 初始化块
{
System.out.println("执行Shape的初始化块...");
}
// 3. 构造器
public Shape() {}
public Shape(String color)
{
System.out.println("执行Shape的构造器...");
this.color = color;
}
// 4. 方法：抽象方法和普通方法都可以
public abstract double calPerimeter();
public void setter(String color)
{
this.color = color;
}
// 5. 内部类(接口、枚举)
}
1. 抽象方法
- 抽象方法没有方法体(只有方法签名，没有方法实现)，只能由子类提供实现(即重写)
- 抽象方法必须能被其子类重写才有意义，即private和abstract不能同时修饰某个方法
- final修饰的方法不能被重写，因此final和abstract不能同时修饰某个方法
- 类方法不能被定义成抽象方法，即static和abstract不能同时修饰某个方法
- 含有抽象方法的类只能被定义成抽象类
2. 抽象类
- 抽象类不能被实例化(不能创建抽象类的实例)，只能当作父类被其他子类继承
- final修饰的类不能被继承，因此final和abstract永远不能同时使用
- 子类只有实现抽象父类里的所有抽象方法，才能被定义成普通类
3. 抽象类的成员：成员变量、方法、初始化块、构造器、内部类(接口、枚举)
- 抽象类里可以没有抽象方法
- 抽象类中的初始化块和构造器都不是在创建该类对象时被调用的(抽象类的构造器不能用于创建实例)，而是在创建其子类的实例时被调用
4. 利用抽象类可以发挥多态的优势，使程序更加灵活
// 下面定义一个Circle普通类，其必须实现Shape里的抽象方法
public class Circle extends Shape
{
private double radius;
public Circle(String color, double radius)
{
super(color);
this.radius = radius;
}
public void setRadius(double radius)
{
this.radius = radius;
}
// 重写Shape类的计算周长的抽象方法
public double calPerimeter()
{
return 2 * Math.PI * radius;
}
public static void main(String[] args)
{
// 定义Shape类型的引用变量s，s指向Circle对象
Shape s = new Circle("黄色", 3);
// 由于在Shape类中定义了calPerimeter()方法，所以程序可以直接调用变量s的calPerimeter()方法
// 无须将变量s强制转换为其子类类型
System.out.println(s.calPerimeter());
}
}
5. 抽象类的作用
不同Shape子类对周长的计算方法是不一样的，即Shape类无法准确地知道其子类计算周长的方法，故Shpe类不知道如何实现calPerimeter()方法。此时若不在Shape类中定义calPerimeter()方法，则Shape引用变量s虽然可以引用到Shape子类的实例，但该变量s却无法调用calPerimeter()方法，必须将其强制转换为其子类类型才行，这就降低了程序的灵活性。这种情况下，我们可以在Shape类中将calPerimeter()方法定义为抽象方法，其具体实现交给子类来完成。也就是说，抽象父类把不能实现的方法定义为抽象方法，留给其子类去实现。
- 从语义的角度来看，抽象类是从多个具体类中抽象出来的父类，它具有更高层次的抽象
- 从多个具有相同特征的类中抽象出一个抽象类，以这个抽象类作为其子类的模板，从而避免了子类设计的随意性
- 抽象类体现的是一种模板模式的设计，抽象类作为多个子类的通用模板，子类在抽象类的基础上进行扩展、改造，但子类总体上会大致保留抽象类的行为方式
二、接口
/*
* 示例：定义一个接口
*/
[修饰符] interface 接口名 extends 父接口1, 父接口2...
{
// 成员1：静态常量
[public static final int] MAX_SIZE = 50;
// 成员2：抽象方法
[public abstract] void getData(String msg);
// 成员3：默认方法
[public] default void test()
{
System.out.println("默认的test()方法");
}
// 成员4：类方法
[public] String staticTest()
{
return "接口里的类方法";
}
// 成员5：私有方法
private void foo()
{
System.out.println("foo私有方法");
}
private static void bar()
{
System.out.println("bar私有静态方法");
}
// 成员6：内部类、内部接口、内部枚举
}
1. 定义接口概述
- 定义接口使用interface关键字
- 修饰符可以是public或省略，如果省略了public访问控制符，则默认采用包权限访问控制符
- 接口名应与类名采用相同的命名规则，通常使用形容词
- 接口只能继承接口，且接口支持多继承(可以有多个直接父接口)
- 一个Java源文件里最多只能有一个public接口，且如果某Java源文件里定义了一个public接口，则该文件名必须与public接口名相同
2. 接口的成员
由于接口里定义的是多个类共同的公共行为规范，因此接口里的成员(除了私有方法)都是public访问权限。
定义接口成员(除了私有方法)时，既可以显式使用public修饰符，也可以省略不写(此时系统会自动添加public修饰符)。
①静态常量
- 接口里的成员变量只能是静态常量，它们是接口相关的
- 在接口中定义成员变量时，不管是否使用public static final修饰符，接口里的成员变量总是使用这三个修饰符来修饰(系统自动添加)
- 由于接口里没有初始化块和构造器，因此接口里的静态常量只能在定义时指定默认值
②抽象方法(无方法体)
- 由于接口里定义的方法只能是抽象方法、类方法、默认方法和私有方法，因此如果不是定义后三种方法，系统将自动为普通方法增加abstract修饰符
- 定义接口里的普通方法时，不管是否使用public abstract修饰符，接口里的普通方法总是使用public abstract来修饰(系统自动添加)
③默认方法(带方法体)
- 默认方法必须使用default修饰，且不能使用static修饰，故不能直接使用接口来调用
- 定义接口里的默认方法时，不管是否使用public修饰符，接口里的默认方法总是使用public来修饰(系统自动添加)
- 接口的默认方法其实就是实例方法，只是多了个default修饰符而已
④类方法(带方法体)
- 类方法必须使用static修饰，且不能使用default修饰，可以直接使用接口来调用
- 定义接口里的类方法时，不管是否使用public修饰符，接口里的默认方法总是使用public来修饰(系统自动添加)
⑤私有方法(带方法体)
- Java9增加了私有方法，这是因为：Java8允许在接口中定义带方法体的默认方法和类方法，那么当两个默认方法(或类方法)中包含一段相同的实现逻辑时，程序必然考虑将这段实现逻辑抽取成工具方法，而工具方法时应该被隐藏的，故Java9增加了私有方法。
⑥内部类、内部接口、内部枚举
- 接口里的内部类、内部接口、内部枚举默认采用public static来修饰(系统自动添加)
3. 接口的作用
- 抽象类是从多个类中抽象出来的模板，如果将这种抽象进行得更彻底，那就得到了“接口”
- 接口定义了某一批类所需要遵守的规范，接口不关心这些类的内部状态数据和方法实现细节，它只规定这些类里必须提供哪些方法
- 接口是从多个相似类中抽象出来的规范，接口不提供任何实现，它体现的是规范和实现分离的设计哲学
- 接口作为系统与外界交互的窗口，它规定了实现者必须向外提供哪些服务，还规定了调用者可以调用哪些服务以及如何调用这些服务
- 当在一个程序中使用接口时，接口是多个模块间的耦合标准；当在多个程序之间使用接口时，接口是多个程序之间的通信标准
4. 抽象类 & 接口
- 抽象类体现的是一种模板式设计，它作为系统中多个子类的抽象父类，已经实现了系统的部分功能(那些已经提供实现的方法)
- 接口体现的是一种规范，它是系统的“总纲”，制定了系统各模块应该遵循的标准，故一个系统的接口不应该经常改变
三、面向接口编程
1. 接口的三大用途
- 定义引用类型变量，该变量必须引用到接口实现类的对象，该变量也可进行强制类型转换
- 调用接口中定义的常量
- 被实现类实现
2. 类实现接口
// 类实现接口的语法格式
[修饰符] class 类名 extends 父类 implements 接口1, 接口2...
{
}
- 类实现接口使用implements关键字
- 一个类可以继承一个父类，并同时实现一个或多个接口，implements部分必须放在extends部分之后
- 类实现接口时，该类将获得接口中定义的静态常量、方法等，故可以把实现接口理解为一种特殊的继承
- 类实现接口时，必须完全实现接口里所定义的全部抽象方法，否则，该类将保留从父接口那里继承到的抽象方法，该类也必须定义成抽象类
- 实现接口方法时，必须使用public访问控制修饰符，因为接口里的方法都是public的，故实现类实现接口里的方法时只能使用public访问权限
3. 模拟多继承
interface Output
{
// 静态常量，系统自动添加public static final修饰符
int MAX_CACHE_LINE = 50;
}
interface Product
{
// 抽象方法，系统自动添加public abstract修饰符
int getProduceTime();
}
// 让Printer类实现Output和Product接口
public class Printer implements Output, Product
{
public int getProduceTime()
{
return 45;
}
public static void main(String[] args)
{
// ex1:创建一个Printer对象，当成Output使用
Output o = new Printer();
// ex2:创建一个Printer对象，当成Product使用
Product p = new Printer();
System.out.println(p.getProduceTime());
// ex3:所有接口类型的引用变量都可直接赋给Object类型的变量
Object obj = p;
}
}
- Printer类实现了Output接口和Product接口，故Printer对象既可直接赋给Output变量，也可直接赋给Product变量
- 彷佛Printer类既是Output类的子类，也是Product类的子类，这就是Java提供的模拟多继承，通过实现多个接口可以弥补单继承的不足
- 虽然接口不能显式继承任何类，但所有接口类型的引用变量都可直接赋给Object类型的引用变量
