Java多态性探悉一、基本概念 多态性：发送消息给某个对象，让该对象自行决定响应何种行为。 通过将子类对象引用赋值给超类对象引用变量来实现动态方法调用。 java 的这种机制遵循一个原则：当超类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法。 1. 如果a是类A的一个引用，那么，a可以指向类A的一个实例,或者说指向类A的一个子类。 2. 如果a是接口A的一个引用，那么,a必须指向实现了接口A的一个类的实例。 二、Java多态性实现机制 SUN目前的JVM实现机制，类实例的引用就是指向一个句柄（handle）的指针，这个句柄是一对指针： 一个指针指向一张表格，实际上这个表格也有两个指针（一个指针指向一个包含了对象的方法表，另外一个指向类对象，表明该对象所属的类型）； 另一个指针指向一块从java堆中为分配出来内存空间。 The Java Virtual Machine does not require any particular internal structure for objects. In Sun's current implementation of the Java Virtual Machine, a reference to a class instance is a pointer to a handle that is itself a pair of pointers: one to a table containing the methods of the object and a pointer to the Class object that represents the type of the object, and the other to the memory allocated from the Java heap for the object data. （jvm规范中关于对象内存布局的说明） 三、总结 1、通过将子类对象引用赋值给超类对象引用变量来实现动态方法调用。 DerivedC c2=new DerivedC(); BaseClass a1= c2; //BaseClass 基类，DerivedC是继承自BaseClass的子类 a1.play(); //play()在BaseClass，DerivedC中均有定义，即子类覆写了该方法 分析： * 为什么子类的类型的对象实例可以覆给超类引用？ 自动实现向上转型。通过该语句，编译器自动将子类实例向上移动，成为通用类型BaseClass； * a.play()将执行子类还是父类定义的方法？ 子类的。在运行时期，将根据a这个对象引用实际的类型来获取对应的方法。所以才有多态性。一个基类的对象引用，被赋予不同的子类对象引用，执行该方法时，将表现出不同的行为。 在a1=c2的时候，仍然是存在两个句柄，a1和c2，但是a1和c2拥有同一块数据内存块和不同的函数表。 2、不能把父类对象引用赋给子类对象引用变量 BaseClass a2=new BaseClass(); DerivedC c1=a2;//出错 在java里面，向上转型是自动进行的,但是向下转型却不是，需要我们自己定义强制进行。 c1=(DerivedC)a2; 进行强制转化,也就是向下转型. 3、记住一个很简单又很复杂的规则，一个类型引用只能引用引用类型自身含有的方法和变量。 你可能说这个规则不对的，因为父类引用指向子类对象的时候，最后执行的是子类的方法的。 其实这并不矛盾，那是因为采用了后期绑定，动态运行的时候又根据型别去调用了子类的方法。而假若子类的这个方法在父类中并没有定义，则会出错。 例如，DerivedC类在继承BaseClass中定义的函数外，还增加了几个函数（例如 myFun()） 分析： 当你使用父类引用指向子类的时候，其实jvm已经使用了编译器产生的类型信息调整转换了。 这里你可以这样理解，相当于把不是父类中含有的函数从虚拟函数表中设置为不可见的。注意有可能虚拟函数表中有些函数地址由于在子类中已经被改写了，所以对象虚拟函数表中虚拟函数项目地址已经被设置为子类中完成的方法体的地址了。 4、Java与C++多态性的比较 jvm关于多态性支持解决方法是和c++中几乎一样的， 只是c++中编译器很多是把类型信息和虚拟函数信息都放在一个虚拟函数表中，但是利用某种技术来区别。 Java把类型信息和函数信息分开放。Java中在继承以后，子类会重新设置自己的虚拟函数表，这个虚拟函数表中的项目有由两部分组成。从父类继承的虚拟函数和子类自己的虚拟函数。 虚拟函数调用是经过虚拟函数表间接调用的，所以才得以实现多态的。 Java的所有函数，除了被声明为final的，都是用后期绑定。 C++实现多态性，使用关键字virtual，为了引起晚捆绑，使用虚函数。若一个函数在基类被声明为virtual，则所有子类中都是virtual的。对虚函数的重定义成为越位。
又放屁. class A{ public method(){ ...... } } class A1 extends A { public method(){ ...... } } class A2 extends A{ public method(){ ...... } } main 方法 A a=new A1(); 出现多态了,对象的引用指向了他子类A1的new出来的对象 ,method方法的指针已经指向A1的method,当他调用method方法时候,调的就是A1的方法 a.method(); 调用A1的method方法,跟重载没关系.只有重写 A a=new A2(); 出现多态了,对象的引用指向了他子类A2的new出来的对象 ,method方法的指针已经指向A2的method,当他调用method方法时候,调的就是A2的方法 a.method(); 调用A2的method方法,跟重载没关系.只有重写
interface Parent { String method(); } class Child1 implements Parent { public String method() { return "Child1 "; } } class Child2 implements Parent { public String method() { return "Child2 "; } } public class Test { public static void main(String[] args) { Parent parent = new Child1(); System.out.println(parent.method()); parent = new Child2(); System.out.println(parent.method()); } } 输出结果： Child1 Child2 只有多个子类从一个父类继承或实现一个接口。 在建立这些子类实例时，都用父类或接口做为变量类型，如上例中的parent。也就是说，用户对应的接口都是一个Parent。而由于new后面的子类不同，而产生调用同一个方法method返回不同结果的显现叫多态。就是同一个方法在使用不同子类时有不同的表现（在这里是不同的返回值）。 方法重载不叫多态。 (转)
在下刚学Java不久，也来说说对Java中多态的认识，请大家指正！ Manager extends Employee之后：------------------------------------------------- （一） Employee e = new Manager(); 此为多态：父类引用指向子类对象。------------------------------------------------- （二） void methodA(Employee e){} main方法中，可以使用 “对象.methodA(new Manager());”来调用这个方法 参数多态！------------------------------------------------- （三） Employee[] e = new Employee[10]; e[0] = new Manager(); 这是多态特性！------------------------------------------------- （四）jdk1.5中 Employee doSomething(){ return new Manager(); } 返回值多态！------------------------------------------------- （五） 如果Employee和Manager中有如下代码： class Employee { public String name="张三"; public void m1(){ System.out.println("Employee::m1()"); } } class Manager extends Employee { public String name="李四"; public void m1(){ System.out.println("Manager::m1()"); } } 再使用如下代码时： Employee e = new Manager(); System.out.println(e.name); e.m1(); //结果会打印出“张三”和“Manager::m1()”。 这是多态中的动态绑定：JVM会自动找到对象e是由Manager类实例化而来的，所以有‘覆盖’时调用Manager中的方法；而属性则不会被动态绑定，所以一定是Employee 中的（e的数据类型被声明为Employee了）。
针对Java多态性,我用一个例子来说明.如其看繁琐难懂的理论,还不如看一个简单明了的例子.class Person { String name; int age; public Person(String name,int age) { this.name=name; this.age=age; } public void call() { System.out.println("Person for class --My name is "+name+";years "+age); } public void method02() { call(); } } class Man extends Person { public Man(String name,int age) { super(name,age); } public void call() { System.out.println("Man for class -- My name is "+name+";years "+age); } }class Woman extends Person { public Woman(String name,int age) { super(name,age); } public void call() { System.out.println("Woman for class -- My name is "+name+";years "+age); } } class Teacher { //老师叫一个人来.不管来的是什么人(男人,女人), 过来请报出自己的姓名和年龄 //***以一应万变***** public static void comeTrue(Person p) { p.call(); p.method02(); } public static void main(String[] args) { Man m=new Man("梅辉",20); Woman w=new Woman("梅依然",18); comeTrue(m); comeTrue(w); }}
public String toString(){ return "This is a "+type+" It's "+name+" the "+breed; } public void sound(){} }//------------------/*Dog类*/ class Dog extends Animal{ public Dog(String name){super("Dog",name,"Unkown");} public Dog(String name,String breed){super("Dog",name,breed);} public void sound(){System.out.println("Wolf Wolf");} }//------------------/*Cat类*/ class Cat extends Animal{
public Cat(String name){super("Cat",name,"Unkown");} public Cat(String name,String breed){super("Cat",name,breed);} public void sound(){System.out.println("Miiawoo");} }//----------------/*Duck类*/ class Duck extends Animal{ public Duck(String name){super("Duck",name,"Unkown");} public Duck(String name,String breed){super("Duck",name,breed);} public void sound(){System.out.println("Quack quack");} }public class Ex6_13{ public static void main(String args[]) { Animal[]theAnimals={ new Dog("Rover","Poodle"), new Cat("Max","Abyssi"), new Duck("Daffy","Ayles") }; Animal petChoice; Random select=new Random(); for(int i=0;i<5;i++){ petChoice=theAnimals[select.nextInt(theAnimals.length)]; System.out.println("\n Your Choice:"+petChoice.toString()); petChoice.sound(); } } }运行结果: Your Choice:This is a Dog It's Rover the Poodle Wolf Wolf Your Choice:This is a Dog It's Rover the Poodle Wolf Wolf Your Choice:This is a Duck It's Daffy the Ayles Quack quack Your Choice:This is a Dog It's Rover the Poodle Wolf Wolf Your Choice:This is a Cat It's Max the Abyssi Miiawoo 程序分析:由于小孩只知道对象是Animal类，所以main()方法声明Animal类的引用Animal petChoice。 petChoice根据实际情况指向Cat类或Dog类或Cuck类对象，每次执行sound()成员方法时都将根据petChoice当前引用的对象调用相应的方法，这就是典型的多态性效果。 [FLY]飞行文字[/FLY]
通过将子类对象引用赋值给超类对象引用变量来实现动态方法调用。 java 的这种机制遵循一个原则：当超类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法。 1. 如果a是类A的一个引用，那么，a可以指向类A的一个实例,或者说指向类A的一个子类。
2. 如果a是接口A的一个引用，那么,a必须指向实现了接口A的一个类的实例。
二、Java多态性实现机制 SUN目前的JVM实现机制，类实例的引用就是指向一个句柄（handle）的指针，这个句柄是一对指针：
一个指针指向一张表格，实际上这个表格也有两个指针（一个指针指向一个包含了对象的方法表，另外一个指向类对象，表明该对象所属的类型）；
另一个指针指向一块从java堆中为分配出来内存空间。 The Java Virtual Machine does not require any particular internal structure for objects. In Sun's current implementation of the Java Virtual Machine, a reference to a class instance is a pointer to a handle that is itself a pair of pointers: one to a table containing the methods of the object and a pointer to the Class object that represents the type of the object, and the other to the memory allocated from the Java heap for the object data. （jvm规范中关于对象内存布局的说明）
三、总结 1、通过将子类对象引用赋值给超类对象引用变量来实现动态方法调用。 DerivedC c2=new DerivedC();
BaseClass a1= c2; //BaseClass 基类，DerivedC是继承自BaseClass的子类
a1.play(); //play()在BaseClass，DerivedC中均有定义，即子类覆写了该方法 分析：
* 为什么子类的类型的对象实例可以覆给超类引用？
自动实现向上转型。通过该语句，编译器自动将子类实例向上移动，成为通用类型BaseClass；
* a.play()将执行子类还是父类定义的方法？
子类的。在运行时期，将根据a这个对象引用实际的类型来获取对应的方法。所以才有多态性。一个基类的对象引用，被赋予不同的子类对象引用，执行该方法时，将表现出不同的行为。 在a1=c2的时候，仍然是存在两个句柄，a1和c2，但是a1和c2拥有同一块数据内存块和不同的函数表。 2、不能把父类对象引用赋给子类对象引用变量 BaseClass a2=new BaseClass();
DerivedC c1=a2;//出错 在java里面，向上转型是自动进行的,但是向下转型却不是，需要我们自己定义强制进行。
c1=(DerivedC)a2; 进行强制转化,也就是向下转型. 3、记住一个很简单又很复杂的规则，一个类型引用只能引用引用类型自身含有的方法和变量。
你可能说这个规则不对的，因为父类引用指向子类对象的时候，最后执行的是子类的方法的。
其实这并不矛盾，那是因为采用了后期绑定，动态运行的时候又根据型别去调用了子类的方法。而假若子类的这个方法在父类中并没有定义，则会出错。
例如，DerivedC类在继承BaseClass中定义的函数外，还增加了几个函数（例如 myFun()） 分析：
当你使用父类引用指向子类的时候，其实jvm已经使用了编译器产生的类型信息调整转换了。
这里你可以这样理解，相当于把不是父类中含有的函数从虚拟函数表中设置为不可见的。注意有可能虚拟函数表中有些函数地址由于在子类中已经被改写了，所以对象虚拟函数表中虚拟函数项目地址已经被设置为子类中完成的方法体的地址了。
4、Java与C++多态性的比较 jvm关于多态性支持解决方法是和c++中几乎一样的，
只是c++中编译器很多是把类型信息和虚拟函数信息都放在一个虚拟函数表中，但是利用某种技术来区别。 Java把类型信息和函数信息分开放。Java中在继承以后，子类会重新设置自己的虚拟函数表，这个虚拟函数表中的项目有由两部分组成。从父类继承的虚拟函数和子类自己的虚拟函数。
虚拟函数调用是经过虚拟函数表间接调用的，所以才得以实现多态的。 Java的所有函数，除了被声明为final的，都是用后期绑定。
C++实现多态性，使用关键字virtual，为了引起晚捆绑，使用虚函数。若一个函数在基类被声明为virtual，则所有子类中都是virtual的。对虚函数的重定义成为越位。
多态就是同一个方法名的多种不同实现所谓的不同实现,是指参数的个数或类型的不同,返回类型可同也可不同为什么要用多态呢??这么给你举个例子,eat,通用是吃
你eat(苹果),甜吧?? 但是要是让你eat(黄连),那就是苦的咯
也就是同一种方名,但是不同的时候(参数)做不同的事
class A{
public method(){
......
}
}
class A1 extends A {
public method(){
......
}
}
class A2 extends A{
public method(){
......
}
}
main 方法 A a=new A1(); 出现多态了,对象的引用指向了他子类A1的new出来的对象 ,method方法的指针已经指向A1的method,当他调用method方法时候,调的就是A1的方法
a.method(); 调用A1的method方法,跟重载没关系.只有重写 A a=new A2(); 出现多态了,对象的引用指向了他子类A2的new出来的对象 ,method方法的指针已经指向A2的method,当他调用method方法时候,调的就是A2的方法
a.method(); 调用A2的method方法,跟重载没关系.只有重写
{
String method();
} class Child1 implements Parent
{
public String method()
{
return "Child1 ";
}
} class Child2 implements Parent
{
public String method()
{
return "Child2 ";
}
} public class Test
{
public static void main(String[] args)
{
Parent parent = new Child1();
System.out.println(parent.method());
parent = new Child2();
System.out.println(parent.method());
}
} 输出结果：
Child1
Child2 只有多个子类从一个父类继承或实现一个接口。 在建立这些子类实例时，都用父类或接口做为变量类型，如上例中的parent。也就是说，用户对应的接口都是一个Parent。而由于new后面的子类不同，而产生调用同一个方法method返回不同结果的显现叫多态。就是同一个方法在使用不同子类时有不同的表现（在这里是不同的返回值）。 方法重载不叫多态。 (转)
Manager extends Employee之后：-------------------------------------------------
（一）
Employee e = new Manager();
此为多态：父类引用指向子类对象。-------------------------------------------------
（二）
void methodA(Employee e){}
main方法中，可以使用 “对象.methodA(new Manager());”来调用这个方法
参数多态！-------------------------------------------------
（三）
Employee[] e = new Employee[10];
e[0] = new Manager();
这是多态特性！-------------------------------------------------
（四）jdk1.5中
Employee doSomething(){
return new Manager();
}
返回值多态！-------------------------------------------------
（五）
如果Employee和Manager中有如下代码：
class Employee {
public String name="张三";
public void m1(){
System.out.println("Employee::m1()");
}
}
class Manager extends Employee {
public String name="李四";
public void m1(){
System.out.println("Manager::m1()");
}
}
再使用如下代码时：
Employee e = new Manager();
System.out.println(e.name);
e.m1();
//结果会打印出“张三”和“Manager::m1()”。
这是多态中的动态绑定：JVM会自动找到对象e是由Manager类实例化而来的，所以有‘覆盖’时调用Manager中的方法；而属性则不会被动态绑定，所以一定是Employee 中的（e的数据类型被声明为Employee了）。
就是子類繼承父類 父類里面有幾個方法
子類可以自行選擇到底調用哪一個（overload或overwrite）
結束了。。
假如你在动物园工作，你一喊，过来，小狮子走过来了，小老虎跑过来了。，而狮子和老虎显然都是不同的物种，但是它们都可以响应你的“过来”消息。它们身为不同的种类，有着相似的行为，但是又不完全相同，这就是世界的多态性。PS：faint，Observer都讲了
{
String name;
int age;
public Person(String name,int age)
{
this.name=name;
this.age=age;
}
public void call()
{
System.out.println("Person for class --My name is "+name+";years "+age);
}
public void method02()
{
call();
}
}
class Man extends Person
{
public Man(String name,int age)
{
super(name,age);
}
public void call()
{
System.out.println("Man for class -- My name is "+name+";years "+age);
}
}class Woman extends Person
{
public Woman(String name,int age)
{
super(name,age);
} public void call()
{
System.out.println("Woman for class -- My name is "+name+";years "+age);
}
}
class Teacher
{
//老师叫一个人来.不管来的是什么人(男人,女人), 过来请报出自己的姓名和年龄
//***以一应万变*****
public static void comeTrue(Person p)
{
p.call();
p.method02();
} public static void main(String[] args)
{
Man m=new Man("梅辉",20);
Woman w=new Woman("梅依然",18);
comeTrue(m);
comeTrue(w);
}}
多态中用到了以下几个面向对象的技术:继承，覆盖，重载多态提供了另外一种分离接口的实现(即把“做什么”与“怎么做”分开)的机制，换句话说多态是在类体系中把设想（想要“怎么做”）和实现（该“怎么做”）分开的手段，它是从设计的角度来考虑的。多态意味着某种抽象的动作可以由特定的方法来实现，这种特定的方法取决于执行该动作的对象。
例如，每天上班时间一到，相当于发了一条这样的命令“员工们，开始上班”（同一条表达式）。每个员工接到这条命令（同样的命令）后，就“开始一班”，但是他们做的是各自的工作，程序员开始“编程”，业务员就开始“联系业务”，网络管理员就开始“监控管理网络”。即“相同的表达式（方法调用），不同的操作（在运行时根据不同的对象来执行）。多态的设计（实例）一个小孩得知邻居家里养了几个宠物，便不知是猫还是狗还是鸭子。于是丢一块石头到邻居家院中探明真相。这里，Animal类作为基类，有一个sound()方法，即发声方法。而Cat类、Dog类和Duck类等都是Animal类的派生类，各有一个与基类Sound()方法同名的覆盖方法。
Animal、Dog、Cat及Duck类之间的关第如下图所示：
Animal类是一个相对抽象的类。在现实世界中，每个动物都一定属于某个特定的种类，因此这个类中的Sound()成员方法的方法体为空，即本身没有任何特定的操作，只是为了实现多态性而设置。在Dog、Ｃat和Duck类中，覆盖了Animal类中的这个方法，它们根据具体动物的特点发出不同的叫声。小孩丢石头，相当于发出命令调用了Animal类对象的Sound()方法，因为小孩不知道是狗还是猫还是鸭子，只知道是宠物。然而实际接收些消息的却是Animal派生类对象，如果是狗，则输出“Wolf Wolf”字符串；如果是猫，则输出“Miiaooww”字符串，如果是鸭子，则输出“Quack quack”字符串。import java.util.Random;class Animal{ /*protected修饰的成员能被类本身和其它所有的子类访问*/
protected String type; //种类
protected String name; //名称
protected String breed; //品种 public Animal(String type,String name,String breed){
this.type=type; /*this有两种方法：一是指明是当前类的成员变量或方法，另一个用途是调用当前对象的另一个构造方法*/
this.name=name;
this.breed=breed;
}
public String toString(){
return "This is a "+type+" It's "+name+" the "+breed;
}
public void sound(){}
}//------------------/*Dog类*/
class Dog extends Animal{ public Dog(String name){super("Dog",name,"Unkown");}
public Dog(String name,String breed){super("Dog",name,breed);}
public void sound(){System.out.println("Wolf Wolf");}
}//------------------/*Cat类*/
class Cat extends Animal{
public Cat(String name){super("Cat",name,"Unkown");}
public Cat(String name,String breed){super("Cat",name,breed);}
public void sound(){System.out.println("Miiawoo");}
}//----------------/*Duck类*/
class Duck extends Animal{ public Duck(String name){super("Duck",name,"Unkown");}
public Duck(String name,String breed){super("Duck",name,breed);}
public void sound(){System.out.println("Quack quack");}
}public class Ex6_13{ public static void main(String args[])
{
Animal[]theAnimals={
new Dog("Rover","Poodle"),
new Cat("Max","Abyssi"),
new Duck("Daffy","Ayles")
};
Animal petChoice;
Random select=new Random();
for(int i=0;i<5;i++){
petChoice=theAnimals[select.nextInt(theAnimals.length)];
System.out.println("\n Your Choice:"+petChoice.toString());
petChoice.sound();
}
}
}运行结果:
Your Choice:This is a Dog It's Rover the Poodle
Wolf Wolf Your Choice:This is a Dog It's Rover the Poodle
Wolf Wolf Your Choice:This is a Duck It's Daffy the Ayles
Quack quack Your Choice:This is a Dog It's Rover the Poodle
Wolf Wolf Your Choice:This is a Cat It's Max the Abyssi
Miiawoo 程序分析:由于小孩只知道对象是Animal类，所以main()方法声明Animal类的引用Animal petChoice。
petChoice根据实际情况指向Cat类或Dog类或Cuck类对象，每次执行sound()成员方法时都将根据petChoice当前引用的对象调用相应的方法，这就是典型的多态性效果。 [FLY]飞行文字[/FLY]