码迷,mamicode.com
首页 > 编程语言 > 详细

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

时间:2014-12-15 17:17:57      阅读:182      评论:0      收藏:0      [点我收藏+]

标签:java   多态   instanceof   

1.多态性

1.概念

向上转型(自动完成)

子类转变成父类

父类  父类对象 子类实例化对象

向下转型(强制)

父类转变成子类,必须首先进行向上转型

子类  子类对象 (子类)父类实例化对象 

2.子类对象向上转型

//本程序是多态性的测试
class A							//定义类A
{
	public void fun1()			//定义类A的fun1方法
	{
		System.out.println("这是类A的fun1方法");
	}
	public void fun2()
	{
		this.fun1();
	}
}
class B extends A				//类B继承类A
{
	public void fun1()			//覆写fun1方法
	{
		System.out.println("这是类B覆写的fun1方法");
	}
	public void fun3()
	{
		System.out.println("这是类B的fun3方法");
	}
}
public class  TestPol
{
	public static void main(String[] args) 
	{
		B b = new B();			//定义子类的实例化对象
		A a = b;				//子类对象向上转型
		a.fun1();				//此方法被子类覆写了,输出的是覆写的
		a.fun2();				//此方法被子类覆写了,输出的是覆写的
	}
}

说明:向上转型使用方法都是子类覆写过的方法。

注意:在A中只能看到两个方法,在B看到三个方法,转型之后,因为操作的是父类,所以无法找到子类中定义的新方法。

//本程序是多态性的测试
class A							//定义类A
{
	public void fun1()			//定义类A的fun1方法
	{
		System.out.println("这是类A的fun1方法");
	}
	public void fun2()
	{
		this.fun1();
	}
}
class B extends A				//类B继承类A
{
	public void fun1()			//覆写fun1方法
	{
		System.out.println("这是类B覆写的fun1方法");
	}
	public void fun3()
	{
		System.out.println("这是类B的fun3方法");
	}
}
public class  TestPol
{
	public static void main(String[] args) 
	{
		B b = new B();			//定义子类的实例化对象
		A a = b;				//子类对象向上转型
		a.fun1();				//此方法被子类覆写了,输出的是覆写的
		a.fun3();				//新方法
	}
}
错误信息提示:

TestPol.java:31: 错误找不到符号

                a.fun3();                               //新方法

                 ^

  符号:   方法 fun3()

  位置类型为A的变量 a

3.父类对象向下转型

//本程序是多态性的测试
class A							//定义类A
{
	public void fun1()			//定义类A的fun1方法
	{
		System.out.println("这是类A的fun1方法");
	}
	public void fun2()
	{
		this.fun1();
	}
}
class B extends A				//类B继承类A
{
	public void fun1()			//覆写fun1方法
	{
		System.out.println("这是类B覆写的fun1方法");
	}
	public void fun3()
	{
		System.out.println("这是类B的fun3方法");
	}
}
public class  TestPol
{
	public static void main(String[] args) 
	{
		B b = new B();			//定义子类的实例化对象
		A a = b;				//子类对象向上转型
		B c = (B) a;			//父类向下转型
		c.fun1();				//此方法被子类覆写了,输出的是覆写的
		c.fun2();				//新方法
	}
}

在类B中存在三个方法,全部可以调用。

注意:进行向下转型操作时,

//本程序是多态性的测试
class A							//定义类A
{
	public void fun1()			//定义类A的fun1方法
	{
		System.out.println("这是类A的fun1方法");
	}
	public void fun2()
	{
		this.fun1();
	}
}
class B extends A				//类B继承类A
{
	public void fun1()			//覆写fun1方法
	{
		System.out.println("这是类B覆写的fun1方法");
	}
	public void fun3()
	{
		System.out.println("这是类B的fun3方法");
	}
}
public class  TestPol
{
	public static void main(String[] args) 
	{
		//B b = new B();			//定义子类的实例化对象
		//A a = b;				//子类对象向上转型
		A a = new A();			//定义父类的实例化对象
		B c = (B) a;			//父类向下转型
		c.fun1();				//此方法被子类覆写了,输出的是覆写的
		c.fun2();				//新方法
	}
}
如果不先进行向上操作的话,会有错误信息。

Exception in thread "main" java.lang.ClassCastException: A cannot be cast to B

        at TestPol.main(TestPol.java:31)

4.对象多态性的应用

要求设计一个方法,能够调用A类任意子类的对象。

//本程序是多态性的测试
class A							//定义类A
{
	public void fun1()			//定义类A的fun1方法
	{
		System.out.println("这是类A的fun1方法");
	}
	public void fun2()
	{
		this.fun1();
	}
}
class B extends A				//类B继承类A
{
	public void fun1()			//覆写fun1方法
	{
		System.out.println("这是类B覆写的fun1方法");
	}
	public void fun3()
	{
		System.out.println("这是类B的fun3方法");
	}
}
class C extends A				//类B继承类A
{
	public void fun1()			//覆写fun1方法
	{
		System.out.println("这是类C覆写的fun1方法");
	}
	public void fun4()
	{
		System.out.println("这是类C的fun4方法");
	}
}
public class  TestPol
{
	public static void main(String[] args) 
	{
		fun(new B());
		fun(new C());
	}
	public static void fun(B b)
	{
		b.fun1();
	}
	public static void fun(C c)
	{
		c.fun1();
	}
}

如果子类过多,无法完成这一目标,可以使用对象多态行完成。

//本程序是多态性的测试
class A							//定义类A
{
	public void fun1()			//定义类A的fun1方法
	{
		System.out.println("这是类A的fun1方法");
	}
	public void fun2()
	{
		this.fun1();
	}
}
class B extends A				//类B继承类A
{
	public void fun1()			//覆写fun1方法
	{
		System.out.println("这是类B覆写的fun1方法");
	}
	public void fun3()
	{
		System.out.println("这是类B的fun3方法");
	}
}
class C extends A				//类B继承类A
{
	public void fun1()			//覆写fun1方法
	{
		System.out.println("这是类C覆写的fun1方法");
	}
	public void fun4()
	{
		System.out.println("这是类C的fun4方法");
	}
}
public class  TestPol
{
	public static void main(String[] args) 
	{
		fun(new B());
		fun(new C());
	}
	public static void fun(A a)
	{
		a.fun1();
	}	
}

2.instanceof 关键字

在对象转型中经常使用

1.概念

java中使用instanceof判断一个对象到底是哪个类的实。

对象   instanceof   类        ---------------->他返回的是boolean

//本程序是isntanceof的测试
class A							//定义类A
{
	public void fun1()			//定义类A的fun1方法
	{
		System.out.println("这是类A的fun1方法");
	}
	public void fun2()
	{
		this.fun1();
	}
}
class B extends A				//类B继承类A
{
	public void fun1()			//覆写fun1方法
	{
		System.out.println("这是类B覆写的fun1方法");
	}
	public void fun3()
	{
		System.out.println("这是类B的fun3方法");
	}
}
public class TestInstanceOf 
{
	public static void main(String[] args) 
	{
		B b = new B();				//定义子类的实例化对象
		A a = b;					//向上转型
		A a2 = new A();
		System.out.println(a instanceof A);
		System.out.println(a instanceof B);
		System.out.println(a2 instanceof A);
		System.out.println(a2 instanceof B);
	}
}

1.作用

如果传入的是B类的实例,调用fun3,如果是C类调用fun4

//本程序是isntanceof的测试
class A							//定义类A
{
	public void fun1()			//定义类A的fun1方法
	{
		System.out.println("这是类A的fun1方法");
	}
	public void fun2()
	{
		this.fun1();
	}
}
class B extends A				//类B继承类A
{
	public void fun1()			//覆写fun1方法
	{
		System.out.println("这是类B覆写的fun1方法");
	}
	public void fun3()
	{
		System.out.println("这是类B的fun3方法");
	}
}
class C extends A				//类B继承类A
{
	public void fun1()			//覆写fun1方法
	{
		System.out.println("这是类C覆写的fun1方法");
	}
	public void fun4()
	{
		System.out.println("这是类C的fun4方法");
	}
}
public class TestInstanceOf 
{
	public static void main(String[] args) 
	{
		fun(new B());
		fun(new C());
	}
	public static void fun(A a)
	{
		if (a instanceof B)
		{
			A a1 = a;			//现在a是子类,先进行向上转换
			B b = (B) a1;		//父类向下转换
			b.fun3();
		}
		if (a instanceof C)
		{
			A a1 = a;			//现在a是子类,先进行向上转换
			C c = (C) a1;		//父类向下转换
			c.fun4();
		}
	}
}

注意:开发中,向下转型操作要进行验证,确保不会出问题。

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

一个类永远不要去继承已经实现好了的类,只能继承抽象类或实现接口。


祝大家健健康康,快快乐乐。








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

标签:java   多态   instanceof   

原文地址:http://blog.csdn.net/baobeizhanshen/article/details/41945543

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!