对象转型有以下几条规则:
1)一个基类的引用类型变量可以“指向”其子类的对象;
2)一个基类的引用不可以访问其子类对象新增加的成员(属性和方法);
3)可以使用引用变量 instanceof 类名 来判断该引用变量所“指向”的对象是否属于该类或该类的子类
4)子类的对象可以当作基类的对象来使用称作向上转型(upcasting),反之称为向下转型(downcasting)。
下面看一个小程序:
public class Test01 {
public static void main(String[] args){
Test01 test = new Test01();
Animal a = new Animal("name");
Cat c = new Cat("catname","blue");
Dog d = new Dog("Dogname","yellow");
test.f(a);
test.f(c);
test.f(d);
}
public void f(Animal a){
System.out.println("name: "+ a.name);
if(a instanceof Cat)
{
Cat cat = (Cat) a;
System.out.println( " " + cat.color +" eyes");
}else if(a instanceof Dog){
Dog dog = (Dog)a;
System.out.println(" "+dog.fur +" fur");
}
}
}
class Animal{
public String name;
public Animal(String name){
this.name = name;
}
}
class Cat extends Animal{
public String color;
public Cat(String name,String color){
super(name);
this.color = color;
}
}
class Dog extends Animal{
public String fur;
public Dog(String name,String fur){
super(name);
this.fur = fur;
}
}
输出结果:
name: name
name: catname
blue eyes
name: Dogname
yellow fur
简单分析:
public void f(Animal a){ ...}参数为基类引用,基类引用“指向”子类对象,可扩展性较好。
######################################################################
下面了解一下面向对象中最核心的一个机制--动态绑定或者多态
所谓动态绑定是指“在执行期间”(而非编译期间)判断所引用对象的实际类型,根据其实际的类型调用相应的方法。
下面是一个小程序:
public class Test02 {
public static void main(String[] args){
Cat c = new Cat("catname","blue");
Dog d = new Dog("dogname","yellow");
Lady l1 = new Lady("Lucy",c);
Lady l2 = new Lady("Lily",d);
l1.myPetEnjoy();
l2.myPetEnjoy();
}
}
class Animal{
private String name;
Animal(String name){
this.name = name;
}
public void enjoy() {
System.out.println("哈哈哈");
}
}
class Cat extends Animal{
private String color;
Cat(String n,String c){
super(n);
this.color = color;
}
public void enjoy(){
System.out.println("喵喵喵");
}
}
class Dog extends Animal{
private String furcolor;
Dog(String s,String n){
super(s);
this.furcolor = n;
}
public void enjoy(){
System.out.println("旺旺旺");
}
}
class Lady{
private String name;
private Animal pet;
Lady(String name ,Animal pet){
this.name = name;
this.pet = pet;
}
public void myPetEnjoy(){
pet.enjoy();
}
}
输出结果:
喵喵喵
旺旺旺
分析:
动态绑定或者多态使得程序的扩展性达到最优!
多态的存在必须有三个条件:
1)要有继承
2)要有重写
3)父类引用指向子类对象