面向对象的程序设计语言的三大特征：封装，继承，多态
封装：根据功能将属性和方法封装到一个类中
继承：实现代码重复利用，避免相同作用代码重复编写（类似函数）
多态：（以封装和继承为前提）多态体现为父类引用变量可以指向子类对象
多态的定义与使用格式：
- 定义格式：父类类型 变量名=new 子类类型();
多态的向上转型和向下转型：
- 向上转型：相当于多态的定义
- 使用格式：父类类型 变量名=new 子类类型();
- 向下转型：使用强制类型转换的格式，将父类引用类型转为子类引用各类型
- 使用格式：子类类型 变量名=（子类类型） 父类类型的变量；
多态的向上转型和向下转型，是通过父类和子类之间的类型转换来实现不同使用情况下的解决方案。如向上转型可以忽略子类类型的限制，并可以使用父类的全局功能。而向下转型又可以适用于子类有特有功能，和方法同名冲突时的调用，可以使不同的子类调用相同的方法，产生不同的结果。
用一个很形象的比喻，一众人去吃火锅，所有人都想吃火锅，所以所有人都属于火锅这一大类，即为父类。而这些人中有人想吃麻辣，有人想吃番茄，这就是火锅这一父类下的子类。对于火锅的属性来说我们需要通过父类来实现，对于火锅口味来说则需要通过子类。
例如：
public class Test {
public static void main(String[] args) {
show(new Tomato()); // 以 Tomato 对象调用 show 方法
show(new Hot()); // 以 Hot 对象调用 show 方法
Hotpot a = new Tomat0(); // 向上转型
a.tasted(); // 调用的是 Tomato 的 tasted
Tomato c = (Tomato)a; // 向下转型
c.price(); // 调用的是 Tomato 的 price
}
public static void show(Hotpot a) {
a.tasted();
// 类型判断
if (a instanceof Tomato) { // 番茄锅的口味
Tomato c = (Tomato)a;
c.price();
} else if (a instanceof Hot) { // 麻辣锅的口味
Hot c = (Hot)a;
c.price();
}
}
}
abstract class Hotpot {
abstract void tasted();
}
class Tomato extends Hotpot {
public void tasted() {
System.out.println("甜");
}
public void price() {
System.out.println("78元");
}
}
class Hot extends Hotpot {
public void tasted() {
System.out.println("辣");
}
public void price() {
System.out.println("67元");
}
}
执行以上程序，输出结果为：
甜
78元
辣
67元
甜
78元
重写
重写的定义：
子类要重写父类方法，需要满足三个条件，
1.相同的方法名
2.相同的参数列表
3.相同的参数类型（参数类型为父类，子类关系也不行，必须相同，否则为重载了）
则，子类方法覆盖父类方法，
一些注意点：
1.构造函数是不能重写的
2.如果子类不能继承父类的方法，如：父类方法是final或者private，是不能重写的
例如：
public class Employee {
private String name;
private String address;
private int number;
public Employee(String name, String address, int number) {
System.out.println("Employee 构造函数");
this.name = name;
this.address = address;
this.number = number;
}
public void mailCheck() {
System.out.println("邮寄支票给： " + this.name
+ " " + this.address);
}
public String toString() {
return name + " " + address + " " + number;
}
public String getName() {
return name;
}
public String getAddress() {
return address;
}
public void setAddress(String newAddress) {
address = newAddress;
}
public int getNumber() {
return number;
}
}
假设下面的类继承Employee类：
public class Salary extends Employee
{
private double salary; // 全年工资
public Salary(String name, String address, int number, double salary) {
super(name, address, number);
setSalary(salary);
}
public void mailCheck() {
System.out.println("Salary 类的 mailCheck 方法 ");
System.out.println("邮寄支票给：" + getName()
+ " ，工资为：" + salary);
}
public double getSalary() {
return salary;
}
public void setSalary(double newSalary) {
if(newSalary >= 0.0) {
salary = newSalary;
}
}
public double computePay() {
System.out.println("计算工资，付给：" + getName());
return salary/52;
}
}
现在我们仔细阅读下面的代码，尝试给出它的输出结果：
public class VirtualDemo {
public static void main(String [] args) {
Salary s = new Salary("员工 A", "北京", 3, 3600.00);
Employee e = new Salary("员工 B", "上海", 2, 2400.00);
System.out.println("使用 Salary 的引用调用 mailCheck -- ");
s.mailCheck();
System.out.println("n使用 Employee 的引用调用 mailCheck--");
e.mailCheck();
}
}
以上实例编译运行结果如下：
Employee 构造函数
Employee 构造函数
使用 Salary 的引用调用 mailCheck –
Salary 类的 mailCheck 方法
邮寄支票给：员工 A ，工资为：3600.0使用 Employee 的引用调用 mailCheck–
Salary 类的 mailCheck 方法
邮寄支票给：员工 B ，工资为：2400.0
例子解析：
- List item实例中，实例化了两个 Salary 对象：一个使用 Salary 引用 s，另一个使用 Employee 引用 e。
- 当调用 s.mailCheck() 时，编译器在编译时会在 Salary 类中找到 mailCheck()，执行过程 JVM 就调用 Salary 类的 mailCheck()。
- e 是 Employee 的引用，但引用 e 最终运行的是 Salary 类的 mailCheck() 方法。
- 在编译的时候，编译器使用 Employee 类中的 mailCheck() 方法验证该语句， 但是在运行的时候，Java虚拟机(JVM)调用的是 Salary 类中的 mailCheck() 方法。
以上整个过程被称为虚拟方法调用，该方法被称为虚拟方法。
Java中所有的方法都能以这种方式表现，因此，重写的方法能在运行时调用，不管编译的时候源代码中引用变量是什么数据类型。
