Java中的多态的详细讲解

转载:http://blog.csdn.net/lin062854/article/details/9347089

多态：同一个符号在不同语义环境下具有不同的解释

一、多态是通过

      1、接口和实现接口并覆盖接口中同一个方法的几种不同的类体现的。

    2、父类和继承父类并覆盖父类中同一方法的几个不同子类实现的。

二、基本概念

       多态性：发送消息给某个对象，让该对象自己决定响应何种行为。

    通过将子类对象引用赋值给超类对象引用变量来实现动态方法调用。

    java的这种机制遵循一个原则：当超类对象引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法。

      1、如果a是类A的一个引用，那么a可以指向类A的一个实例，或者说指向类A的一个子类。

      2、如果a是接口A的一个引用，那么a必须指向实现了接口A的一个类的实例。

三、多态的分类

1.强制的：一种隐式做类型转换的方法。

        强制多态隐式的将参数按某种方法，转换成编译器认为正确的类型以避免错误。在一下的表达式中，编译器必须决定二元运算符‘+’所应做的工作：        

[java] view plain copy

1. int a = 1 + 2;  
2. double d = 2.0 + 2.0;  
3. String s = "abc" + "def";  

2.方法的重载：将一个标志符用作多个意义。

        重载允许用相同的运算符或方法，去表示截然不同的意义。‘+’在上面的程序中有几个不同意思：两个int型相加；两个double型相加；两个串相连。另外还有整型相加，长整型，等等。这些运算符的重载，依赖于编译器根据上下文做出的选择。以往的编译器会把操作数隐式转换为完全符合操作数的类型。虽然Java明确支持重载，但不支持用户定义的操作符重载。

        Java支持用户定义的函数重载。一个类中可以有相同名字的方法，这些方法可以有不同的意义。这些重载的方法中，必须满足参数数目不同，相同位上的参数类型不同。这些方法可以帮助编译器区分不同版本的方法。

         编译器以这种唯一表示的特征来表示不同的方法，比用名字表示更为有效。据此，所有的多态行为都能编译通过。

         强制和重载的多态都被分类为特定的多态，因为这些多态都是在特定的意义上的。这些被划入多态的特性给程序员带来了很大的方便。强制多态排除了麻烦的类型和编译错误。重载多态像一块糖，运行程序员用相同的名字表示不同的方法，很方便。

         

[java] view plain copy

1. public class One {  
2.   
3.        //方法体   
4.   
5.    }  
6.   
7.    public class Two extends One {  
8.   
9.       //方法体  
10.   
11.    }  
12.   
13.   public class A {   
14.   
15.       public void f() {  
16.   
17.          //方法体  
18.   
19.       }  
20.   
21.      public void f(int i) {  
22.   
23.         //方法体   
24.   
25.       }  
26.   
27.     public viod f(One one) {  
28.   
29.         //方法体  
30.   
31.      }  
32.   
33.     public One f() {  
34.   
35.        //方法体  
36.   
37.      }  
38.   
39.   }  
40.   A a = new A();  
41.   
42.   a.f();  
43.   
44.   a.f(1);  

3.方法的重写

         发生在父类与子类中，在子类中重写了父类/超类中的同名方法，在调用子类的该同名方法时父类中的同名方法被“屏蔽”，重写子类与父类有相同的方法名参数列表（类型、个数、顺序）和返回类型（子类重写的方法的返回类型相同或者是父类返回值的子类）

[java] view plain copy

1. public class B extends A {  
2.   
3.       public void f() {...}     
4.   
5.       public void f(int j) {...}             //重写  
6.   
7.        public void f(Two two) {...}    //不是重写  
8.   
9.        public Two f() {...}                   //重写  
10.   
11.  }  

4、向上转型

           子类自有的方法不可见

         1）、代码检查不允许。

         2）、从实际意义上

[java] view plain copy

1. A a = new B();  
2. a.f();     //调用子类的f()方法  
3. a.f(new Two());    //编译错误(定义一个A类引用，JVM解释a.f(new Two())方法时，A类没有这个方法)  

5、向下转型

          存在于继承中，父类引用指向的对象实际是要转型的子类引用的类型。

[java] view plain copy

1. 1)  Animal a = new Dog();  
2.   
3.       Dog d = (Dog) a;    //正确  
4.   
5. 2) Animal a = new Cat();  
6.   
7.       Dog d = (Dog) a;    //抛异常