Java基础之多态性

原创 2015年07月07日 20:51:43
Demo1
class A {
    public void fun1(){
       System.out.println("A--->public fun1()");
    }
    public void fun2(){
         this.fun1();
    }
};
class B extends A{
    public void fun1(){
      System.out.println("B---->public void fun1()");
    }
    public void fun3(){
       System.out.println("B------>public void fun3()");
    }
};

public class PolDemo {
	   public static void main(String[] args){
		      B b = new B();//实例化对象
		      A a=b;//向上转型关系
		      a.fun1();
		      a.fun2();
		     // a.fun3();
		   }
};

运行输出;

B---->public void fun1()
B---->public void fun1()

结论:将B强转A 是以A 为对照实体,所以 不存在fun3() ;如果子类重写父类,先执行子类,找不到在到父类中找;


Demo2

再改改上面的例子:

public class PolDemo {
	   public static void main(String[] args){
             A a=new A();
             B b=a;//报错,不能转换,原因类与类之间的关系不明确。这就是向下转型,所不取的地方;
             b.fun1();//报错
             
		   }
};

输出:报错;

结论:类与类之间,必须存在明确的关系才能转换。


Demo3

public class PolDemo {
	   public static void main(String[] args){
             A a= new B();//向上转型
             B b=(B)a;//向下转型,这是可以的,因为上面的那句已经确定他和他老子的关系啦
             a.fun1();
             a.fun2();
             
         }
};

输出:

B---->public void fun1()
B---->public void fun1()
结论:如果想发生一个向下转型,必须发生一个向上转型,不然就根本无法做到;


Java多态性的应用:

class A {
    public void fun1(){
       System.out.println("A--->public fun1()");
    }
    public void fun2(){
         this.fun1();
    }
};
class B extends A{
    public void fun1(){
      System.out.println("B---->public void fun1()");
    }
    public void fun3(){
       System.out.println("B------>public void fun3()");
    }
};

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

public class PolDemo {
	   public static void main(String[] args){
         fun1(new B());
         fun1(new C());
         
	   }
	   public static void fun1(A a){
		   a.fun1();
	   }
}
当有无数个类多继承A时,都可以轻松完成,或对代码进行轻松的维护;这只需要修改new X() 就可以了,这类是于工厂;

他这一强大的优点让人无法忽视啊。


用 instanceof 验证类与类的关系:

public class PolDemo {
	   public static void main(String[] args){
         A a1 = new B();
         System.out.println("A a1 =new B() : "+(a1 instanceof A));
         System.out.println("A a1 =new B() : "+(a1 instanceof B));
         
         A a2=  new A();
         System.out.println("A a2 =new B() : "+(a2 instanceof A));
         System.out.println("A a2 =new B() : "+(a2 instanceof B));
         
//         A a3=new A();
//         B b1=(B)a;//IDE 报错;
//         System.out.println("B b1 =new B() : "+(a2 instanceof A));
//         System.out.println("B b1 =new B() : "+(a2 instanceof B));
         
	   }

输出:

A a1 =new B() : true
A a1 =new B() : true
A a2 =new B() : true
A a2 =new B() : false


典型糟糕的Demo

public class PolDemo {
	   public static void main(String[] args){
         A a1 = new B();
         System.out.println("A a1 =new B() : "+(a1 instanceof A));
         System.out.println("A a1 =new B() : "+(a1 instanceof B));
         
         A a2=  new A();
         System.out.println("A a2 =new B() : "+(a2 instanceof A));
         System.out.println("A a2 =new B() : "+(a2 instanceof B));
         
         B b3=(B)new A();//IDE 没出错,但运行出错啦!向下转型;糟糕的到吗
         A a3= (A) b3;
         System.out.println("B b1 =new B() : "+(a2 instanceof A));
         System.out.println("B b1 =new B() : "+(a2 instanceof B));
         
	   }
}
IDE 没保存,但编译出错!向下转型,类与类的关系不确定啊!

=====================这是经常忽视的问题!================

所以,在向下转型时,最好增加  instanceof   验证 来保证程序不会出错!


进一步优化的Demo

思考:如何优化一下代码:

package basic.java.linknode;


class A {
    public void fun1(){
       System.out.println("A--->public fun1()");
    }
    public void funA(){
         this.fun1();
    }
};
class B extends A{
    public void fun1(){
      System.out.println("B---->public void fun1()");
    }
    public void funB(){
       System.out.println("B------>public void funB()");
    }
};


class C extends  A{
<span style="white-space:pre">	</span> public void fun1(){
<span style="white-space:pre">		</span> System.out.println("C---->public void fun1()");
<span style="white-space:pre">	</span> }
<span style="white-space:pre">	</span> public void funC(){
<span style="white-space:pre">		</span> System.out.println("C---->public void funC()");
<span style="white-space:pre">	</span> }
};


public class PolDemo {
<span style="white-space:pre">	</span>   public static void main(String[] args){
<span style="white-space:pre">		</span>   
<span style="white-space:pre">		</span>   fun(new B());
<span style="white-space:pre">		</span>   fun(new C());//与定义的顺序有关!
<span style="white-space:pre">	</span>   }
<span style="white-space:pre">	</span>   
<span style="white-space:pre">	</span>   public static void fun(A a){
<span style="white-space:pre">		</span>   System.out.println("===========Begin============");
<span style="white-space:pre">		</span>   a.fun1();
<span style="white-space:pre">		</span>   if(a instanceof B){
<span style="white-space:pre">			</span>   B b=(B)a;
<span style="white-space:pre">			</span>   b.funB();
<span style="white-space:pre">		</span>   }
<span style="white-space:pre">		</span>   if(a instanceof C){
<span style="white-space:pre">			</span>   C c=(C) a;
<span style="white-space:pre">			</span>   c.funC();
<span style="white-space:pre">		</span>   }
<span style="white-space:pre">		</span>   System.out.println("===========End============");
<span style="white-space:pre">	</span>   }


   }
}
如果要增加新子类,则肯定要修改fun()方法,这样一来程序就失去了灵活性,所以在程序开发重点的设计应该放在父类上,只要父类设计的足够合理,则开发肯定非常方便;

         =======》 记住:一个类一定不能去继承一个实现好的类。而只能继承抽象类或实现接口;《=======


版权声明:转载注明出处

C++基础之多态性与虚函数

(1)多态定义:计算机在编译时或运行时,根据我们实际的代码自动调用不同的函数的能力为多态。 (2)多态分类: (编译时)静态多态:前期绑定:a)函数重载                        ...

c++基础---C++之多态性与虚函数

转自:http://www.cnblogs.com/CaiNiaoZJ/archive/2011/08/11/2134673.html  面向对象程序设计中的多态性是指向不同的对象发送同一个消息,不...

12-15java面向对象之多态性操作

1.多态性 1.概念 向上转型(自动完成) 子类转变成父类 父类  父类对象 = 子类实例化对象 向下转型(强制) 父类转变成子类,必须首先进行向上转型 子类  子类对象 = (子类)父...

java学习笔记之多态性

在阅读Core Java有关多态内容之后,对多态理解加深了好多,上网找了多态相关的代码,并把自己对多态的理解梳理整理之后写在博客上,以便以后需要时复习复习...

胡博君解Java之多态性

欢迎大家收看我的在线Java全套免费教学超清视频: http://v.youku.com/v_show/id_XODQ1NjU0NDc2.html 这是其中的一个视频连接,大家可以拖动到优酷视频...

Java虚拟机学习之多态性实现机制——静态分派与动态分派

来自:http://wiki.jikexueyuan.com/project/java-vm/polymorphism.html 方法解析 Class 文件的编译过程中不包含传统编...

黑马程序员——Java之多态性

——–Java培训、Android培训、iOS培训、.Net培训、期待与您交流! ——-函数的重写(覆盖): * (1)当子类和父类中出现一摸一样的函数时(包括返回值类型,不包括权限修饰...

C++实验之多态性和虚函数

  • 2017年11月07日 09:41
  • 1KB
  • 下载

C++程序设计教程之多态性

  • 2010年12月27日 14:08
  • 336KB
  • 下载

C++之多态性与虚函数

面向对象程序设计中的多态性是指向不同的对象发送同一个消息,不同对象对应同一消息产生不同行为。在程序中消息就是调用函数,不同的行为就是指 不同的实现方法,即执行不同的函数体。也可以这样说就是实现了...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:Java基础之多态性
举报原因:
原因补充:

(最多只允许输入30个字)