視其所以，觀其所由，察其所安。
上文提到，面向对象的一个重要概念封装。就是把现实世界的具体东西抽象后成为一个类的过程。
接下来就面向对象概念的抽象、封装延伸出来的几个重要的概念进行讲解，包括：继承（inheritance）、多态（polymorphism）、重载（Overloading）和覆盖（Overriding）。
1. 继承（inheritance）
延续上一篇的例子，我们来修改一下程序，我们增加一个新的接口Hibernation(可冬眠的)，把大象继承可冬眠的，修改后的程序如下:
可冬眠的接口（Hibernation.java）
/**
* 接口可冬眠的（Hibernation）
*/
interface Hibernation{
void hibernating();
String getName();
}
大象类(Elephant.java)
/**
* Elephant 继承 Hibernation
*/
public class Elephant implements Hibernation{
private String name = "";
public Elephant(String name) {
this.name = name;
}
/**
* 覆盖 Hibernation 的冬眠方法
*/
@Override
public void hibernating() {
System.out.println("Elephant("+name+") on hibernating!");
}
/**
* 覆盖 Hibernation 的获取名字方法
*/
@Override
public String getName() {
return name;
}
}
冰箱类（Refrigerator.java）
class Refrigerator {
private List<Hibernation> box = new ArrayList();
private boolean doorStatus = false;
public void openDoor(){
doorStatus = true;
System.out.println("door opened");
}
public void closeDoor(){
doorStatus = false;
System.out.println("door closed");
}
public void addThing(Hibernation obj){
if(doorStatus){
box.add(obj);
obj.hibernating();
System.out.println("Freezable Thing added.");
}else{
System.out.println("door is close, please open it first!");
}
public void getThing(int index){
if(doorStatus){
box.get(index);
System.out.println("Thing take out.");
}else{
System.out.println("door is close, please open it first!");
}
}
执行类(MainApplication.java)
class MainApplication{
// 创建一个冰箱的实例
Refrigerator refrigerator = new Refrigerator();
//创建一个大象的实例（名字）
Elephant elephantOlivia = new Elephant("Olivia");
//命运三部曲
//1.打开冰箱门
refrigerator.openDoor();
//2.把名字叫Olivia的大象放进去
refrigerator.addThing(elephantOlivia);
//3.把冰箱门关上
refrigerator.closeDoor();
//第四部
//4.把冰箱东西拿出来
refrigerator.getThing(0);
}
}
运行结果：
运行结果
大象继承了可冬眠接口就叫--继承(inheritance):
class Elephant implements Hibernation
2.多态（polymorphism）
在解析多态时我们要引入一个新物种，蛇(snake)。同样蛇也继承可冬眠接口
/**
* Snake 继承 Hibernation
*/
public class Snake implements Hibernation {
private String name = "";
public Snake(String name) {
this.name = name;
}
/**
* 覆盖 Hibernation 的获取名字方法
*/
@Override
public String getName() {
return name;
}
/**
* 覆盖 Hibernation 的冬眠方法
*/
@Override
public void hibernating() {
System.out.println("Snake(" + name + ") on hibernating~~~");
}
}
然后我们来修改下执行类：(MainApplication.java)
class MainApplication{
// 创建一个冰箱的实例
Refrigerator refrigerator = new Refrigerator();
//创建一个大象的实例（名字）
Elephant elephantOlivia = new Elephant("Olivia");
//创建一个蛇的实例（名字）
Snake snakeJade = new Snake("Jade");
//命运三部曲
//1.打开冰箱门
refrigerator.openDoor();
//2.把名字叫Olivia的大象放进去
refrigerator.addThing(elephantOlivia);
//3.把名字叫Jade的蛇放进去
refrigerator.addThing(snakeJade);
//4.把冰箱门关上
refrigerator.closeDoor();
//第四部
//4.把冰箱东西拿出来
refrigerator.getThing(0);
}
}
运行结果：
运行结果
大家发现了吗？把东西放入冰箱的方法同样是addThing()，然而当放入的是大象时调用大象的冬眠方法，放入蛇时调用蛇的冬眠方法。这就是多态（polymorphism）。
3.重载（Overloading）和覆盖（Overriding）
理解了上面这两种结构后对于重载（Overloading）和覆盖（Overriding）就很好理解了。简单的说重载和覆盖就是对方法的两种不同的重构方式。细心的读者应该注意到Elephant和Snake的hibernating()方法和getName()方法我都标注了，是的他们其实都覆盖了Hiberation的方法。这里也可以理解为覆盖，但是对于接口的覆盖我们一般说为实现了XX接口的方法。
覆盖--指子类用同名同参数的方法重写了父类的方法。
重载--指在同一个类里有同名的方法却接收不同的参数。
我们把冰箱类修改如下：
import java.util.ArrayList;
import java.util.List;
public class Refrigerator {
private List<Hibernation> box = new ArrayList();
private boolean doorStatus = false;
public void openDoor() {
doorStatus = true;
System.out.println("door opened.");
}
public void closeDoor() {
doorStatus = false;
System.out.println("door closed.");
}
public void addThing(Hibernation obj) {
if (doorStatus) {
box.add(obj);
obj.hibernating();
System.out.println("Thing added.");
} else {
System.out.println("door is close, please open it first!");
}
}
public Hibernation getThing(int index) {
if (doorStatus) {
System.out.println("Thing take out.");
return box.get(index);
} else {
System.out.println("door is close, please open it first!");
return null;
}
}
/**
* 重载 getThing() 方法
*/
public Hibernation getThing(Hibernation obj) {
if (doorStatus) {
System.out.println("Thing take out.");
int index = box.indexOf(obj);
return box.get(index);
} else {
System.out.println("door is close, please open it first!");
return null;
}
}
}
修改后的冰箱类添加了getThing(Hibernation obj)方法，与老方法重名并且返回同样都类型却接收不同的参数。这就叫重装。
修改下执行类：(MainApplication.java)
public class MainApplication {
public static void main(String[] args) {
// 创建一个冰箱的实例
Refrigerator refrigerator = new Refrigerator();
//创建一个大象的实例（名字）
Elephant elephantOlivia = new Elephant("Olivia");
//创建一个蛇的实例（名字）
Snake snakeJade = new Snake("Jade");
//命运三部曲
//1.打开冰箱门
refrigerator.openDoor();
//2.把名字叫Olivia的大象放进去
refrigerator.addThing(elephantOlivia);
//3.把名字叫Jade的蛇放进去
refrigerator.addThing(snakeJade);
//3.把冰箱门关上
refrigerator.closeDoor();
//第四部
//4.把冰箱东西拿出来
refrigerator.getThing(0);
//拿取三部曲
//4.把冰箱东西拿出来
//1.打开冰箱门
refrigerator.openDoor();
//2.把蛇和第一个物品拿出来
refrigerator.getThing(snakeJade);
refrigerator.getThing(0);
//3.把冰箱门关上
refrigerator.closeDoor();
}
}
大家运行上面的的代码看看运行结果吧。
今天就到这里，下次再见！谢谢，有问题欢迎私信留言给我，记得点赞关注+分享哦。
