一个变量只能有一种确定的数据类型
一个引用类型变量可能指向(引用)多种不同类型的对象
子类可看做是特殊的父类，所以父类类型的引用可以指向子类的对象：向上转型(upcasting)。
例：Person p = new Student();
Object o = new Person(); //Object类型的变量o，指向Person类型的对象
o = new Student(); //Object类型的变量o，指向Student类型的对象
一个引用类型变量如果声明为父类的类型，但实际引用的是子类对象，那么该变量就不能再访问子类中添加的属性和方法。
方法声明的形参类型为父类类型，可以使用子类的对象作为实参调用该方法。

1.3.2 子类继承父类

若子类重写了父类方法，就意味着子类里定义的方法彻底覆盖了父类里的同名方法，系统将不可能把父类里的方法转移到子类中。
对于实例变量则不存在这样的现象，即使子类里定义了与父类完全相同的实例变量，这个实例变量依然不可能覆盖父类中定义的实例变量

1.4 多态的使用

虚拟方法调用(Virtual Method Invocation)

1.4.1 虚拟方法定义

定义：子类中定义了与父类同名同参数的方法，在多态情况下，将此时父类的方法称为虚拟方法;

1.4.2 虚拟方法的调用

调用：
当调用子父类同名同参数的方法时，实际执行的是子类重写父类的方法
父类根据赋给它的不同子类对象，动态调用属于子类的该方法。这样的方法调用在编译期是无法确定的。
例： Person e = new Student();
e.getInfo(); // 调用Student 类的getInfo()
注意：（动态绑定）区分编译时类型和运行时类型；编译时e为Person类型，而方法的调用是在运行时确定的，所以调用的是Student类的getInfo()方法。
总结：
多态情况下，
“ 看左边 ” ：看的是父类的引用（父类中不具备子类特有的方法）
“ 看右边 ” ：看的是子类的对象（实际运行的是子类重写父类的方法）

1.5 对象类型转换 (Casting)

1.5.1 基本数据类型的转换

自动类型转换：小的数据类型可以自动转换成大的数据类型
强制类型转换：可以把大的数据类型强制转换(casting)成小的数据类型
如 float f=(float)12.0; int a=(int)1200L

1.5.2 多态情况下类型转换

对Java对象的强制类型转换称为造型(向下转型)

向上转型：（从子类到父类的类型转换）自动进行，通过多态
向下转型：（从父类到子类的类型转换）必须通过造型(强制类型转换)实现，使用之前需要用 instanceof 进行条件判断。
无继承关系的引用类型间的转换是非法的
注意：使用向下转型，容易出现异常：ClassCastException; 因此需要用 instanceof 进行关系确认。

1.5.3 instanceof 操作符

格式：x instanceof A 检验 x 是否为类 A 的对象，返回值为boolean型。
x是变量名，A是类型。
注意：

要求x所属的类与类A必须是子类和父类的关系，否则编译错误。
x instanceof A 返回值为true；类B为类A的父类，则 x instanceof B 返回值也是true；
instanceof 运算符判定父类引用指向子类实例对象的具体类型。

二、面试经典例题

2.1 方法的重载与重写区分

从定义上区分：
从编译和运行的角度看：
重载，是指允许存在多个同名方法，而这些方法的参数不同。编译器根据方法不同的参数表，对同名方法的名称做修饰。
对于编译器而言，这些同名方法就成了不同的方法。它们的调用地址在编译期就绑定了。
Java的重载是可以包括父类和子类的，即子类可以重载父类的同名不同参数的方法。
所以对于重载而言，在方法调用之前，编译器就已经确定了所要调用的方法，这称为“早绑定”或“静态绑定”；
重写，（多态）只有等到方法调用的那一刻，解释运行器才会确定所要调用的具体方法，这称为“晚绑定”或“动态绑定”。
引用一句Bruce Eckel的话：“不要犯傻，如果它不是晚绑定，它就不是多态。”

代码展示

// 虚方法调用测试
class PersonPy {
String name;
int age;
int id = 1001;

public void eatpy(){
System.out.println("人：吃饭");
}

public void walkpy(){
System.out.println("人：走路");
}

}
class Man extends PersonPy{

boolean isSmoking;

int id = 1002;

public void earnMoney(){
System.out.println("男人负责挣钱养家");
}

public void eat(){
System.out.println("男人多吃肉，长肌肉");
}

public void walk(){
System.out.println("男人霸气的走路");
}

}
class Woman extends PersonPy{

boolean isBeauty;

public void goShopping(){
System.out.println("女人喜欢购物");
}

public void eat(){
System.out.println("女人少吃，为了减肥");
}

public void walk(){
System.out.println("女人窈窕的走路");
}
}
class PersonPyTest {
public static void main(String[] args) {
PersonPy p1 = new PersonPy();
p1.eatpy();

Man man = new Man();
man.eat();
man.age = 25;
man.earnMoney();

System.out.println("*******************");
//对象的多态性：父类的引用指向子类的对象
PersonPy p2 = new Man();
//Person p3 = new Woman();
//多态的使用：当调用子父类同名同参数的方法时，实际执行的是子类重写父类的方法 ---虚拟方法调用
p2.eatpy();
p2.walkpy();

//		p2.earnMoney();
System.out.println(p2.id); //1001

System.out.println("****************************");
//不能调用子类所特有的方法、属性：编译时，p2是Person类型。
p2.name = "Tom";
//		p2.earnMoney();
//		p2.isSmoking = true;
//有了对象的多态性以后，内存中实际上是加载了子类特有的属性和方法的，但是由于变量声明为父类类型，导致
//编译时，只能调用父类中声明的属性和方法。子类特有的属性和方法不能调用。

//如何才能调用子类特有的属性和方法？
//向下转型：使用强制类型转换符。
Man m1 = (Man)p2;
m1.earnMoney();
m1.isSmoking = true;

//使用强转时，可能出现ClassCastException的异常。
//		Woman w1 = (Woman)p2;
//		w1.goShopping();

if(p2 instanceof Woman){
Woman w1 = (Woman)p2;
w1.goShopping();
System.out.println("******Woman******");
}

if(p2 instanceof Man){
Man m2 = (Man)p2;
m2.earnMoney();
System.out.println("******Man******");
}

if(p2 instanceof PersonPy){
System.out.println("******Person******");
}
if(p2 instanceof Object){
System.out.println("******Object******");
}

//练习：
//问题一：编译时通过，运行时不通过
//举例一：
//		Person p3 = new Woman();
//		Man m3 = (Man)p3;
//举例二：
//		Person p4 = new Person();
//		Man m4 = (Man)p4;

//问题二：编译通过，运行时也通过
//		Object obj = new Woman();
//		Person p = (Person)obj;

//问题三：编译不通过
//		Man m5 = new Woman();

//		String str = new Date();

//		Object o = new Date();
//		String str1 = (String)o;

}
}

内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理

标签：

相关文章推荐

新的分享

章节导航