[2014-3-14]JAVA笔记_多态(Polymophism)、instanceof关键字

一、什么是多态？

         Polymorphism means “different forms.” In object-oriented programming, you have the same interface from the base class, and different forms using that interface: the different versions of the dynamically bound methods. (摘自thinking in java, Page217)  polymorphism
(also called dynamic bindingor late bindingor run-time binding)

例子：多态，子类-->父类  向上转型

public class PolyTest
{
public static void main(String[] args)
{
//Parent parent = new Parent();
//parent.sing();

//Child child = new Child();
//child.sing();

Parent p = new Child();		//子类即父类
p.sing();
}
}

class Parent
{

public void sing()
{
System.out.println("parent is singing");
}

}

class Child extends Parent
{
//public void sing(int i)	//重载
public void sing()
{
System.out.println("child is singing");
}
}
//Note:当申明父类型的引用去指向字类型的对象时，父类调用方法原则：第一，会去
//父类中查看是否有此方法，如果有继续查找此方法是否有被子类继承，如果继承
//则继续查找此方法是否覆写，如果覆写则调用覆写的方法，如果没有被覆写则直接
//调用父类中的方法。第二，如果父类型的引用调用方法时此方法在父类中没有定义，则直接会报错，因为什么类型的引用就能调用什么类型的方法。
//(与重载无关，如果子类重载了父类的方法，调用时任然是调用父类的方法，如果有
//被覆写则调用覆写的方法)

为什么要向上转型？

 a) 可以保持父类不需要修改，只需要子类继承父类，然后覆写父类的方法。

 b)可以用父类型引用，接受子类型引用参数，这样父类方法不需要改变，只需要增加子类即可。（详见第二十讲最后大约10分钟）

public class PolyTest5
{
/*
public void runCar(BMW bmw)	//不使用多态：子类添加，方法也必须添加。
{
bmw.run();
}

public void runCar(QQ qq)	//传的都是具体的车的类型。QQ不能接受BMW
{
qq.run();
}
*/

//使用多态：无论子类增加多少类，父类方法不需要修改
public void runCar(Car car)		//可接受car类型和car的子类类型
{
car.run();
}

public static void main(String[] args)
{
/*
PolyTest5 test = new PolyTest5();

BMW bmw = new BMW();

test.runCar(bmw);

QQ qq = new QQ();

test.runCar(qq);
*/

PolyTest5 test = new PolyTest5();

Car car = new BMW();	//通过多态自动向上转换实现

test.runCar(car);

QQ qq = new QQ();

test.runCar(qq);	//子类引用传递给父类方法接受。向上类型转换

}
}

class Car
{
public void run()
{
System.out.println("car is running");
}
}

class BMW extends Car
{
public void run()
{
System.out.println("BMW is running");
}
}

class QQ extends Car
{
public void run()
{
System.out.println("QQ is running");
}
}

//总结：多态屏蔽掉了子类之间的差异性，用一个公共父类方法标识我的接口(方法的参数)
//不管子类怎么改变，只要增加的子类都继承了这个父类，都可以作为参数传递到我的这个
//方法里。

多态的晚绑定：

//验证晚绑定
public class PolyTest4
{
public static void main(String[] args)
{
A a = null;

if(args[0].equals("1"))
{
a = new B();
}
else if(args[0].equals("2"))
{
a = new C();
}
else if(args[0].equals("3"))
{
a = new D();
}

a.method();
}
}

class A
{
public void method()
{
System.out.println("A");
}
}

class B extends A
{
public void method()
{
System.out.println("B");
}
}

class C extends A
{
public void method()
{
System.out.println("C");
}
}

class D extends A
{
public void method()
{
System.out.println("D");
}
}

向下转型：

例子：多态，父类-->子类， 向下转型

public class PolyTest2
{
public static  void main(String[] args)
{
/*
Animal animal = new Cat();
Animal animal2 = new Animal();

animal2 = animal;
animal2.sing();
*/

/*
Animal animal = new Cat();
Animal animal2 = new Animal();

animal = animal2;
animal.sing();
*/

/*
Cat cat = new Cat();
Animal animal = cat;
animal.sing();
*/

Animal animal = new Animal();
Cat cat =new Animal();

/*	//向上类型转换
Cat cat = new Cat();

Animal animal = cat;

animal.sing();

//向下类型转换
Animal a = new Cat();

Cat c = (Cat)a;		//向下转换的原则是：a实际指向的是什么，就可以把它转换成什么类型的引用

c.sing();
*/
}
}

class Animal
{
public void sing()
{
System.out.println("animal is singing");
}
}

class Dog extends Animal
{
public void sing()
{
System.out.println("dog is singing");
}
}

class Cat extends Animal
{
public void sing()
{
System.out.println("cat is singing");
}
}

为什么要使用向下转换？

例子：

public class PolyTest3
{
public static void main(String[] args)
{
//Fruit f = new Pear();
//f.run();

//Pear p = (Pear)f;
//p.run();

//Fruit f = new Pear();
//f.grow();

Fruit f = new Pear();

Pear p = (Pear)f;

p.grow();

}
}

class Fruit
{
public void run()
{
System.out.println("fruit is running");
}
}

class Pear extends Fruit
{
public void run()
{
System.out.println("pear is running");
}

public void grow()
{
System.out.println("pear is growing");
}
}

总结：子类里面新增了自己的方法时，父类引用需要调用子类方法此时就需要向下转型。将父类引用类型转型为子类引用类型，因为什么类型的引用就能指向什么类型的对象。

1. JAVA中面向对象主要有两种提现：

(1) 方法的重载与覆写。

(2) 对象的多态性。

对象的多态性主要分为以下两种类型：

（1） 向上转型：子类对象——>父类对象。

（2） 向下转型： 父类对象——>子类对象。

对于向上转型，程序会自动完成，而对于向下转型时，必须明确地指明要转型的子类类型。

【格式
对象转型】

对象向上转型：
父类 父类对象 = 子类实例；

对象向下转型：
子类 子类对象 = （子类）父类实例；

范例：对象的向上转型

//对象的向上转型
class A{					//定义类A
public void fun1(){
System.out.println("A --> public void fun1(){}");
}
public void fun2(){
this.fun1();
}
};
class B extends A{				//子类通过extends继承父类
public void fun1(){			//覆写父类中的fun1()方法
System.out.println("B --> public void fun1(){}");
}
public void fun3(){			//子类自己定义的方法
System.out.println("B --> public void fun3()");
}
};
public class PolDemo01{
public static void main(String []args){
B b = new B();			//定义子类实例化对象
A a = b;				//发生了向上转型的关系，子类 --> 父类
a.fun1();				//此方法被子类覆写过
}
}
//总结：如果对象发生了向上转型关系后，所调用的方法一定是被子类覆写过的方法。

程序运行结果：

B --> public void fun1(){}

此时的对象a是无法调用B类中的fun3()方法的，因为此方法只在子类定义，而没有在父类中定义，如果想要调用子类自己的方法，则肯定要使用子类实例，所以此时可以将对象进行向下转型。

//对象的向下转型
class A{					//定义类A
public void fun1(){
System.out.println("A --> public void fun1(){}");
}
public void fun2(){
this.fun1();
}
};
class B extends A{				//子类通过extends继承父类
public void fun1(){			//覆写父类中的fun1()方法
System.out.println("B --> public void fun1(){}");
}
public void fun3(){			//子类自己定义的方法
System.out.println("B --> public void fun3(){}");
}
};
public class PolDemo02{
public static void main(String []args){
A a = new B();			//发生了向上转型的关系，子类-->父类
B b = (B)a;				//此时发生了向下转型关系
b.fun1();				//调用方法被覆写的方法
b.fun2();				//调用父类的方法
b.fun3();				//调用子类自己定义的方法
}
}

程序运行结果：

B --> public void fun1(){}

B --> public void fun1(){}

B --> public void fun3(){}

总结：如果想要调用子类自己的方法，则一定只能用子类声明对象，另外，在子类中调用了父类中的fun2()方法，fun2()方法要调用fun1()方法，但此时fun1()方法已经被子类所覆写，所以，此时调用的方法是被子类覆写过的方法。

注意： 对象向下转型的要求

在进行对象的向下转型前，必须首先发生对象向上转型，否则将出现对象转换异常

//错误的转型
class A{					//定义类A
public void fun1(){
System.out.println("A --> public void fun1(){}");
}
public void fun2(){
this.fun1();
}
};
class B extends A{				//子类通过extends继承父类
public void fun1(){			//覆写父类中的fun1()方法
System.out.println("B --> public void fun1(){}");
}
public void fun3(){			//子类自己定义的方法
System.out.println("B --> public void fun3(){}");
}
};
public class PolDemo03{
public static void main(String []args){
A a = new A();			//此时声明的是父类对象。父对象并不知道谁是子对象
B b = (B)a;				//此时发生了向下转型关系
b.fun1();				//调用方法被覆写的方法
b.fun2();				//调用父类的方法
b.fun3();				//调用子类自己定义的方法
}
}

由以上程序可以发现，此时的A类对象是由A类本身进行实例化的，然后将A类的实例化对象强制转换为子对象，这样写在语法上是没有任何错误的，但是在运行时出现了异常，因为此时父类用其本身类实例化自己的对象，但它并不知道谁是自己的子类，那肯定在转换时会出现错误。只需要将连个对象建立好关系即可解决此我呢提，在声明父类对象时发生向上转型关系“A a = new B();”，这时相当于是由子类去实例化父类对象，也就是说这时父类知道有这么一个子类，所以下面在进行转换时就不会再有问题。

2. instanceof 关键字：判断某个对象是否是某个类的实例。

语法形式： 引用名  instanceof  类名（接口名），返回 boolean  值。

//Instanceof 关键字作用
public class InstanceofTest{
public static void main(String args[]){

People people = new Man();

System.out.println(people instanceof People);

//因为 Man 是 People 的子类，根据继承，子类就是父类，
//因此 Man 也可以看作是 People 的实例。
}
}

class People{};
class Man extends People{};

//使用instanceof判断一个对象属于那个类的实例
class A{					//定义类A
public void fun1(){
System.out.println("A --> public void fun1(){}");
}
public void fun2(){
this.fun1();
}
};
class B extends A{				//子类通过extends继承父类
public void fun1(){			//覆写父类中的fun1()方法
System.out.println("B --> public void fun1(){}");
}
public void fun3(){			//子类自己定义的方法
System.out.println("B --> public void fun3(){}");
}
};
public class InstanceofDemo01{
public static void main(String []args){
A a1 = new B();				//通过向上转型实例化A类对象
System.out.println("A a1 = new B():" + (a1 instanceof A));
System.out.println("A a1 = new B():" + (a1 instanceof B));
A a2 = new A();				//通过A类的构造实例化本类对象
System.out.println("A a2 = new A():" + (a2 instanceof A));
System.out.println("A a2 = new A():" + (a2 instanceof B));
}
}
//通过子类实例化的对象同时是子类和父类的实例

程序运行结果：

A a1 = new B():true

A a1 = new B():true

A a2 = new A():true

A a2 = new A():false

//在向下转型前进行验证
class A{					//定义类A
public void fun1(){
System.out.println("A --> public void fun1(){}");
}
public void fun2(){
this.fun1();
}
};
class B extends A{				//子类通过extends继承父类
public void fun1(){			//覆写父类中的fun1()方法
System.out.println("B --> public void fun1(){}");
}
public void fun3(){			//子类自己定义的方法
System.out.println("B --> public void fun3(){}");
}
};
class C extends A{				//子类通过extends继承父类
public void fun1(){			//覆写父类中的fun1()方法
System.out.println("C --> public void fun1(){}");
}
public void fun5(){			//子类自己定义的方法
System.out.println("C --> public void fun3(){}");
}
};
public class InstanceofDemo02{
public static void main(String []args){
fun(new B());			//传递B类实例，产生向上转型
fun(new C());			//传递C类实例，产生向上转型
}
public static void fun(A a){	//此方法可以分别调用各自子类单独定义的方法
a.fun1();
if(a instanceof B){			//判断是否是B类实例
B b = (B)a;				//进行向下转型
b.fun3();				//调用子类自己定义的方法
}
if(a instanceof C){			//判断是否是C类实例
C c = (C)a;				//进行向下转型
c.fun5();				//调用子类自己定义的方法
}
}
}

程序运行结果：

B --> public void fun1(){}

B --> public void fun3(){}

C --> public void fun1(){}

C --> public void fun3(){}