1、多态的含义和特性
（1）多态（polymorphism）意为一个名字可具有多种语义。在程序设计语言中,多态性是指”一种定义，多种实现”。例如，运算符“+”有多种含义，究竟执行哪种运算取决于参加运算的操作数类型：
1+2 //加法运算符
“1” + “2” //字符串连接运算,操作数是字符串（2）类的多态性提供类中成员设计的灵活性和方法执行的多样性。在Java中的体现：
- 对象的多态性：父类的引用指向子类的对象
（3）Java引用变量有两个类型：编译时类型和运行时类型。编译时类型由声明该变量时使用的类型决定，运行时类型由实际赋给该变量的对象决定。简称：编译时，看左边；运行时，看右边。 若编译时类型和运行时类型不一致，就出现了对象的多态性（Polymorphism）。 多态情况下：
- “看左边” ：看的是父类的引用（父类中不具备子类特有的方法）
- “看右边” ：看的是子类的对象（实际运行的是子类重写父类的方法）
即多态的成员方法：
- 编译时：要查看引用变量所声明的类中是否有所调用的方法。
- 运行时：调用实际new的对象所属的类中的重写方法。
（4）多态作用： 提高了代码的通用性，常称作接口重用。
前提： 需要存在继承或者实现关系；有方法的重写。
成员变量： 不具备多态性，只看引用变量所声明的类。
（5）对象的多态
- 在Java中,子类的对象可以替代父类的对象使用
- 一个变量只能有一种确定的数据类型
- 一个引用类型变量可能指向(引用)多种不同类型的对象
Person p = new Student();
Object o = new Person();//Object类型的变量o，指向Person类型的对象
o = new Student(); //Object类型的变量o，指向Student类型的对象子类可看做是特殊的父类，所以父类类型的引用可以指向子类的对象：向上转型（upcasting）。
（6）一个引用类型变量如果声明为父类的类型，但实际引用的是子类对象，那么该变量就不能再访问子类中添加的特有的属性和方法。
Student m = new Student();
m.school = “pku”; //合法,Student类有school成员变量
Person e = new Student();
e.school = “pku”; //非法,Person类没有school成员变量属性是在编译时确定的，编译时e为Person类型，没有school成员变量，因而编译错误。
2、多态性应用
（1）方法声明的形参类型为父类类型，可以使用子类的对象作为实参调用该方法。
public class Test {
public void method(Person e) { // ……
e.getInfo();
}
public static void main(Stirng args[]) {
Test t = new Test();
Student m = new Student();
t.method(m); // 子类的对象m传送给父类类型的参数e
}
}（2）虚拟方法调用(Virtual Method Invocation)
- 正常的方法调用：
Person e = new Person();
e.getInfo();
Student e = new Student();
e.getInfo();- 虚拟方法调用(多态情况下)
子类中定义了与父类同名同参数的方法，在多态情况下，将此时父类的方法称为虚拟方法，父 类根据赋给它的不同子类对象，动态调用属于子类的该方法。这样的方法调用在编译期是无法 确定的。
Person e = new Student();
e.getInfo(); //调用Student类的getInfo()方法编译时e为Person类型，而方法的调用是在运行时确定的，所以调用的是Student类的getInfo()方法。——动态绑定
- 前提：Person类中定义了getInfo()方法，各个子类重写了getInfo()。
- 执行：多态的情况下，调用对象的getInfo()方法， 实际执行的是子类重写的方法。
3、instanceof 操作符
x instanceof A;//检验x是否为类A的对象，返回值为boolean型。要求x所属的类与类A必须是子类和父类的关系，否则编译错误。
如果x属于类A的子类B，x instanceof A值也为true。
public class Person extends Object {…}
public class Student extends Person {…}
public class Graduate extends Person {…}public void method1(Person e) {
if (e instanceof Person)
// 处理Person类及其子类对象 true
if (e instanceof Student)
//处理Student类及其子类对象 false
if (e instanceof Graduate)
//处理Graduate类及其子类对象 false
}4、对象类型转换（Casting）
对Java对象的强制类型转换称为造型：
- 从子类到父类的类型转换可以自动进行
- 从父类到子类的类型转换必须通过造型(强制类型转换)实现
- 无继承关系的引用类型间的转换是非法的
- 在造型前可以使用instanceof操作符测试一个对象的类型
例子1：
public class ConversionTest {
public static void main(String[] args) {
double d = 13.4;
long l = (long) d;
System.out.println(l);
int in = 5;
// boolean b = (boolean)in;
Object obj = "Hello";
String objStr = (String) obj;
System.out.println(objStr);
Object objPri = new Integer(5);
// 所以下面代码运行时引发ClassCastException异常
String str = (String) objPri;
}
}例子2：
public class Test {
public void method(Person e) {
// 设Person类中没有getschool() 方法
// System.out.pritnln(e.getschool()); //非法,编译时错误
if (e instanceof Student) {
Student me = (Student) e; // 将e强制转换为Student类型
System.out.pritnln(me.getschool());
}
}
public static void main(String[] args){
Test t = new Test();
Student m = new Student();
t.method(m);
}
}继承成员变量和继承方法的区别：
//父类
class Base {
int count = 10;
public void display() {
System.out.println(this.count);
}
}//子类
class Sub extends Base {
int count = 20;
public void display() {
System.out.println(this.count);
}
}//测试类
public class FieldMethodTest {
public static void main(String[] args){
Sub s = new Sub();
System.out.println(s.count); //20
s.display(); //20
Base b = s;
System.out.println(b == s); //true
System.out.println(b.count); //10
b.display(); //20
}
}若子类重写了父类方法，就意味着子类里定义的方法彻底覆盖了父类里的同名方法，系统将不可能把父类里的方法转移到子类中。
对于实例变量则不存在这样的现象，即使子类里定义了与父类完全相同的实例变量，这个实例变量依然不可能覆盖父类中定义的实例变量。
5、多态总结
（1）多态存在的三个必要条件
- 要有继承；
- 要有重写；
- 父类引用指向子类对象。
（2）多态性有两种:
- 编译时多态性
对于多个同名方法，如果在编译时能够确定执行同名方法中的哪一个，则称为编译时多态性。 - 运行时多态性
在编译时不能确定，只能在运行时才能确定执行多个同名方法中的哪一个，则称为运行时多态性。
（3）类多态性表现
- 方法重载
重载表现为同一个类中方法的多态性。一个类生命多个重载方法就是为一种功能提供多种实现。编译时，根据方法实际参数的数据类型、个数和次序，决定究竟应该执行重载方法中的哪一个。 - 子类重定义从父类继承来的成员
当子类从父类继承来的成员不适合子类时，子类不能删除它们，但可以重定义它们，使父类成员适应子类的新需求。子类重定义父类成员，同名成员在父类与子类之间表现出多态性，父类对象引用父类成员，子类对象引用子类成员，不会产生冲突和混乱。
子类可重定义父类的同名成员变量，称子类隐藏父类成员变量。子类也可以重定义父类的同名成员方法，当子类方法的参数列表与父类方法参数列表完全相同时，称为子类方法覆盖（override）父类方法。覆盖父类方法时，子类方法的访问权限不能小于父类方法的权限。
由于Object类的equals()方法比较两个对象的引用是否相等而不是值是否相等，因此一个类要覆盖Object类的equals()方法，提供本类两个对象比较相等方法。
覆盖表现为父类与子类之间方法的多态性。java 寻找执行方法的原则是：从对象所属的类开始，寻找匹配的方法执行，如果当前类中没有匹配的方法，则逐层向上依次在父类或祖先类中寻找匹配方法，直到Object类。
6、Object类的使用
（1）Object类是所有Java类的根父类。
如果在类的声明中未使用extends关键字指明其父类，则默认父类为java.lang.Object类。
public class Person { ... }等价于：
public class Person extends Object { ... }（2）==操作符与equals方法==：
基本类型比较值，即只要两个变量的值相等，即为true。
int a=5; if(a==6){…}引用类型比较引用(是否指向同一个对象)：只有指向同一个对象时，==才返回true。
Person p1=new Person();
Person p2=new Person();
System.out.println(p1==p2)//false用==进行比较时，符号两边的数据类型必须兼容(可自动转换的基本 数据类型除外)，否则编译出错。
equals()：
所有类都继承了Object，也就获得了equals()方法。equals()方法还可以重写。 equals()方法只能比较引用类型，其作用与==相同，比较是否指向同一个对象。
语法格式：
obj1.equals(obj2)特例：
当用equals()方法进行比较时，对类File、String、Date及包装类（Wrapper Class）来说，是比较类型及内容而不考虑引用的是否是同一个对象；
原因：在这些类中重写了Object类的equals()方法。
当自定义使用equals()时，可以重写。用于比较两个对象的“内容”是否都相等。
重写equals()方法的原则：
对称性：如果x.equals(y)返回是“true” ，那么y.equals(x)也应该返回是 “true”。
自反性：x.equals(x)必须返回是“true”。
传递性：如果x.equals(y)返回是“true” ，而且y.equals(z)返回是“true” ， 那么z.equals(x)也应该返回是“true”。
一致性：如果x.equals(y)返回是“true” ，只要x和y内容一直不变，不管你重复x.equals(y)多少次，返回都是“true”。
任何情况下，x.equals(null)，永远返回是“false” ； x.equals(和x不同类型的对象)永远返回是“false”。
int it = 65;
float fl = 65.0f;
System.out.println(“65和65.0f是否相等？” + (it == fl)); //true
char ch1 = 'A';
char ch2 = 12;
System.out.println("65和'A'是否相等？" + (it == ch1));//true
System.out.println(“12和ch2是否相等？" + (12 == ch2));//true
String str1 = new String("hello");
String str2 = new String("hello");
System.out.println("str1和str2是否相等？"+ (str1 == str2));//false
System.out.println("str1是否equals str2？"+(str1.equals(str2)));//true
System.out.println(“hello” == new java.util.Date()); //编译不通过（3）toString() 方法
toString()方法在Object类中定义，其返回值是String类型，返回类名和它 的引用地址。
在进行String与其它类型数据的连接操作时，自动调用toString()方法。
Date now=new Date();
System.out.println(“now=”+now); //相当于下列语句
System.out.println(“now=”+now.toString());可以根据需要在用户自定义类型中重写toString()方法
如String类重写了toString()方法，返回字符串的值。
s1=“hello”;
System.out.println(s1);//相当于下列语句
System.out.println(s1.toString());基本类型数据转换为String类型时，调用了对应包装类的toString()方法
int a=10;
System.out.println(“a=”+a);
