抽象类
前面学习继承时,我们会把多个子类中相同的属性和方法提取到父类中,让子类直接使用。但有些行为虽然大家都有,具体做法却不一样,这时候该怎么办呢?
比如人都有工作的行为,但老师、程序员的工作内容显然不同。如果在 Person 中写一个通用的 work() 方法,就很难确定方法体究竟该写什么。
这种情况下,可以先在父类中规定:所有人都应该有 work() 方法,但具体做什么由子类决定。 这就用到了抽象方法。
抽象方法与抽象类
- 抽象方法:使用
abstract修饰,只有方法声明,没有方法体,具体实现留给子类。 - 抽象类:使用
abstract修饰的类。如果一个类中有抽象方法,那么这个类必须是抽象类。
例如:
public abstract class Person {
public abstract void work();
}这里的 work() 只有方法名和参数等信息,后面直接以分号结束,没有 {} 方法体。
抽象方法和抽象类的写法分别是:
public abstract 返回值类型 方法名(参数列表);
public abstract class 类名 {
}上面只是语法格式,实际写代码时要换成具体的方法名和类名。
抽象类的使用注意事项
- 抽象类不能直接创建对象。 例如
new Person()会报错,因为Person中的work()还没有具体实现。 - 抽象类不一定要有抽象方法。 但只要一个类包含抽象方法,它就必须声明为抽象类。
- 抽象类可以有构造方法。 虽然不能直接创建抽象类对象,但创建子类对象时,仍然会调用父类的构造方法。
- 子类需要处理继承来的抽象方法。 如果子类是普通类,就要实现继承来的所有抽象方法;如果没有实现完,那子类也必须是抽象类。
抽象类里也可以写普通的成员变量和有方法体的方法,并不是所有内容都要用 abstract 修饰。
接口
继承可以把一类事物共有的内容放在父类中。但有些行为并不只属于某一种事物。
例如,青蛙是动物,会游泳;学生是人,也可能会游泳。我们不可能仅仅因为它们都会游泳,就让青蛙和学生继承同一个“会游泳的父类”。
这时候可以把“会游泳”这个行为单独定义成一个接口,需要游泳功能的类再去实现它。
可以先这样理解:继承更多是在说明“它是什么”,接口更多是在说明“它能做什么”。
接口的定义与使用
接口使用 interface 定义,类通过 implements 实现接口:
public interface Swim {
void swim();
}
// 这里只演示写法,Animal 类在后面的完整示例中定义
class Frog extends Animal implements Swim {
// 需要实现 Animal 中的抽象方法和 Swim 中的抽象方法
}接口本身不能直接创建对象。普通的实现类需要实现接口要求的抽象方法;如果没有全部实现,那么这个类也要声明为抽象类。
一个类可以实现多个接口,也可以在继承一个父类的同时实现多个接口,例如:
class 子类 extends 父类 implements 接口1, 接口2 {
}注意这里的逗号是英文逗号。实际编写时,把这些名称换成已经定义好的类和接口即可。
用动物的例子理解接口
现在来写一个完整的例子:兔子、青蛙和狗都属于动物,所以可以共同继承 Animal;但只有青蛙和狗需要游泳功能,于是再让它们实现 Swim 接口。
关系可以整理成这样:
Animal(抽象类,规定 eat())
├── Rabbit:继承 Animal,实现 eat()
├── Frog :继承 Animal,实现 eat();实现 Swim
└── Dog :继承 Animal,实现 eat();实现 Swim
Swim(接口,规定 swim())
├── Frog 实现
└── Dog 实现对应代码如下:
public class Test1 {
public static void main(String[] args) {
Frog f = new Frog("青蛙", 3);
System.out.println(f.getName() + "," + f.getAge());
f.eat();
f.swim();
Rabbit r = new Rabbit("兔子", 2);
r.eat();
Dog d = new Dog("狗", 5);
d.eat();
d.swim();
}
}
abstract class Animal {
private String name;
private int age;
public Animal() {
}
public Animal(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public abstract void eat();
}
interface Swim {
public abstract void swim();
}
class Rabbit extends Animal {
public Rabbit() {
}
public Rabbit(String name, int age) {
super(name, age);
}
@Override
public void eat() {
System.out.println("兔子吃胡萝卜");
}
}
class Frog extends Animal implements Swim {
public Frog() {
}
public Frog(String name, int age) {
super(name, age);
}
@Override
public void eat() {
System.out.println("青蛙吃虫子");
}
@Override
public void swim() {
System.out.println("青蛙在游泳");
}
}
class Dog extends Animal implements Swim {
public Dog() {
}
public Dog(String name, int age) {
super(name, age);
}
@Override
public void eat() {
System.out.println("狗吃骨头");
}
@Override
public void swim() {
System.out.println("狗在游泳");
}
}运行结果:
青蛙,3
青蛙吃虫子
青蛙在游泳
兔子吃胡萝卜
狗吃骨头
狗在游泳这里有两个值得注意的地方。
首先,Animal 中的 eat() 是抽象方法,所以 Rabbit、Frog 和 Dog 都需要根据自己的情况来实现它。兔子吃胡萝卜,青蛙吃虫子,狗吃骨头,正好体现了“行为相同,具体实现不同”。
其次,Swim 只规定要有 swim(),并不要求所有动物都实现它。青蛙和狗实现了 Swim,就需要编写游泳方法;兔子没有实现,所以也不需要写 swim()。
接口中可以定义哪些成员?
接口中的成员与普通类有所不同:
| 成员 | 特点 |
|---|---|
| 成员变量 | 只能是常量,默认带有 public static final |
| 构造方法 | 接口没有构造方法,也不能直接创建对象 |
| 抽象方法 | 默认带有 public abstract,这两个关键字可以省略 |
| 有方法体的方法 | 从 JDK 8 开始,可以有 default 方法和静态方法;从 JDK 9 开始,还可以有私有方法 |
例如:
interface Swim {
int MAX_DISTANCE = 100; // 相当于 public static final int MAX_DISTANCE = 100;
void swim(); // 相当于 public abstract void swim();
}所以,在前面完整例子中,我们写 public abstract void swim(); 没有问题,直接简写成 void swim(); 也可以。
类与接口之间的关系,也可以放在一起对比:
| 关系 | 使用的关键字 | 特点 |
|---|---|---|
| 类继承类 | extends | 只能有一个直接父类,但可以多层继承 |
| 类实现接口 | implements | 可以实现一个或多个接口,同时还可以继承一个类 |
| 接口继承接口 | extends | 一个接口可以继承多个接口 |
例如,接口之间也可以这样写:
interface A {
}
interface B {
}
interface C extends A, B {
}JDK 8:接口中的默认方法
以前接口中的普通方法声明基本都是抽象方法,实现类需要把这些方法全部实现。
假如一个接口已经被很多类实现了,现在我们想给接口增加一个新功能。如果直接添加抽象方法,那么原来那些普通实现类也都需要补上这个方法,否则就会报错。但有些类暂时根本用不到这个功能,全部修改就很麻烦。
因此,JDK 8 增加了默认方法,使用 default 修饰,并且有方法体。实现类可以直接使用默认方法,不一定非要重写;如果有自己的需求,也可以选择重写。
例如,在 Swim 中增加一个“游泳前热身”的默认方法:
interface Swim {
void swim();
public default void warmUp() {
System.out.println("游泳前先热身");
}
}这样一来,前面实现了 Swim 的 Frog 和 Dog 即使不新增 warmUp(),也可以使用接口提供的默认实现。如果某个类希望采用自己的热身方式,再重写 warmUp() 就可以了,重写时不写 default。
这里的 public 可以省略,但 default 不能省略。
还有一种情况需要注意:如果一个类实现的多个接口中,出现了相同的默认方法,产生冲突时,实现类需要自己重写这个方法。 先记住这个规则即可。
JDK 8:接口中的静态方法
除了默认方法,JDK 8 还允许接口定义静态方法,使用 static 修饰:
interface Swim {
public static void showTip() {
System.out.println("游泳时要注意安全");
}
}
public class Test1 {
public static void main(String[] args) {
Swim.showTip();
}
}运行结果:
游泳时要注意安全接口的静态方法要通过接口名调用,比如 Swim.showTip(),不能通过实现类名或者对象来调用。这里的 public 同样可以省略,但 static 不能省略。
JDK 9:接口中的私有方法
到了 JDK 9,接口还可以定义私有方法。主要是为了把接口内部重复使用的代码提取出来,让默认方法或静态方法调用,而不需要把这些内部细节公开出去。
有两种写法:
private void method() {
// 供接口内部使用的普通私有方法
}
private static void staticMethod() {
// 供接口内部使用的静态私有方法
}它们都需要写在接口内部,不能在接口外面直接调用。这里先了解格式和用途就可以了。
适配器设计模式
前面说过,一个普通类实现接口后,需要实现接口中的全部抽象方法。但如果一个接口有十个方法,而我们只需要使用第五个方法呢?
按照正常写法,另外九个方法虽然暂时用不到,也得写出来。方法一多,代码里就会出现一大堆空实现。
这时候可以在接口和真正使用它的类之间加一个适配器类(Adapter):先让适配器实现接口中的所有方法,并提供空的方法体;以后需要使用其中几个方法,就继承这个适配器,只重写自己需要的方法。这里说的是接口适配器的写法。
为了方便看清楚,下面用五个方法举例。假设我们只需要 method5():
interface Action {
void method1();
void method2();
void method3();
void method4();
void method5();
}
// 适配器负责把接口中的方法先实现一遍
abstract class ActionAdapter implements Action {
@Override
public void method1() {
}
@Override
public void method2() {
}
@Override
public void method3() {
}
@Override
public void method4() {
}
@Override
public void method5() {
}
}
// 真正需要使用接口功能的类
class MyAction extends ActionAdapter {
@Override
public void method5() {
System.out.println("只需要第五个方法");
}
}
public class Test1 {
public static void main(String[] args) {
MyAction action = new MyAction();
action.method5();
}
}输出:
只需要第五个方法这样,MyAction 只需要重写 method5(),其他方法已经由 ActionAdapter 提供了空实现。
这个中间的适配器通常会用 abstract 修饰,因为它只是为了让其他类继承,没有必要直接创建适配器对象。注意,即使抽象类中没有抽象方法,也可以用 abstract 修饰,前面学过的抽象类特点在这里就用上了。
所以适配器模式在这个例子中的思路其实很简单:接口要求的方法太多,就先用一个中间类把它们实现好,真正使用的类只挑需要的方法重写。以后遇到“接口要求实现很多方法,但当前类只用到其中一部分”的情况,就可以想到这种写法。
聊两句
评论审核后显示有疑问、补充,或者想交流一下,都可以写在这里。
评论区将在滚动到这里时加载。