java对象的多态性

最新推荐文章于 2022-07-25 15:48:06 发布

原创最新推荐文章于 2022-07-25 15:48:06 发布 · 723 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java #多态 #上转型对象

java 同时被 2 个专栏收录

25 篇文章

订阅专栏

多态

1 篇文章

订阅专栏

1. 定义

如果B类是A类的子类或间接子类，当用B类创建对象b并将这个对象b的引用赋给A类对象a时，如：
A a;
a = new B();
OR
A a;
B b = new B();
a = b;
则称A类对象a是子类B对象b的上转型对象。

2. 性质

对象b的上转型a的实体是有子类B创建的，但是上转型对象会失去子类B的一些属性和功能。上转型对象具有以下特点：
1.上转型对象不能操作子类新增加的成员变量，不能使用子类新增的方法。即为较子类B失去一些属性和功能，这些属性和功能是新增的。
2.上转型对象可以操作子类继承或隐藏的成员变量，也可以使用子类继承的或重写的方法。即为上转型对象可以操纵父类原有的属性和功能，无论这些方法是否被重写。
3.上转型对象调用方法时，就是调用子类继承和重写过的方法。而不会是新增的方法，也不是父类原有的方法。
可以将对象的上转型对象再强制转换到一个子类对象，强制转换过的对象具有子类所有属性和功能。

3. 举例

如：
OutputStream output;
output = new FileOutputStream(filename);

并且根据Java API知
java.lang.Object
java.io.OutputStream

java.io.FileOutputStream

这时，output就是上转型对象啦。有什么特殊呢？就是output可以使用FileOutputStream从父类OutputStream那里继承来的方法和重写的方法，而不能使用子类FileOutputStream自己新增的方法啦。最后，这种方法是很常用的哦。。。当父类有很多子类时，就能实现方法的多态。

多态中非静态成员方法的特点

在编译时，参阅引用型变量所属的类中是否有调用的方法。如果有，则编译通过，如果没有没有则编译失败。
在运行时，参阅对象所属的类中是否有调用的方法。

简单总结：成员方法在多态调用的时候编译时看左边，运行时看右边。

多态中静态成员方法的特点

编译和运行都看左边。

多态中成员变量的特点

无论编译或者运行的时候都看左边（引用型变量所属的类）。

/**
 * 多态中成员方法和成员变量的特点
 * 非静态成员方法：编译时看左边（父类），运行时看右边（子类）
 * 静态成员方法：编译和运行都参考左边（父类）
 * 成员变量：编译和运行都看左边（父类）
 */

class Fu{
	
	static int count = 100;	// 父类中的静态成员变量
	int num = 100;			// 父类中的非静态成员变量
	
	public void fun1(){
		System.out.println("父类中的fun1方法");
	}
	public void fun2(){
		System.out.println("父类中的fun2方法");
	}
	public static void fun4(){
		System.out.println("父类中的fun4静态方法");
	}
}

class Zi extends Fu{
	
	static int count = 0; 	// 子类中的静态成员变量
	int num = 0; 			// 子类中的非静态成员变量
	
	@Override
	public void fun1() {
		System.out.println("子类中的fun1方法，覆写了父类的fun1方法");
	}
	
	public void fun3(){
		System.out.println("子类中的fun3方法，此方法是子类特有的");
	}
	
	public static void fun4(){
		System.out.println("子类中的fun4静态方法");
	}
}

public class PolymorphismDemo {

	public static void main(String[] args) {
		
		Fu obj = new Zi();
		obj.fun1();	// 调用子类重写的方法，输出“子类中的fun1方法，覆写了父类的fun1方法”
		obj.fun2();	// 子类中没有重写fun2，则调用父类的fun2方法，打印“父类中的fun2方法”
//		obj.fun3();	//编译失败，因为父类中没有fun3方法，fun3方法是子类特有的
		obj.fun4();	// fun4是父类和子类都有的静态方法，打印“父类中的fun4静态方法”（因为Fu obj加载的是父类，静态不需要创建对象直接调用方法）
		
		System.out.println("obj.num = " + obj.num);		// 非静态成员变量编译和运行都看左边即num = 100
		System.out.println("obj.count = " + obj.count);	// 静态成员变量在类加载的是否确定值，看左边即count = 100
	}
}

对象的多态性

在对象实例化的时候A a = new B()，中满足B is-a A的关系（因为B extends A），而A a = new A()，中同样满足A is-a A的关系。

多态数组

abstract class Animal {
	public abstract void eat();

	public void sleep() {
		System.out.println("动物睡觉！");
	}
}

class Dog extends Animal {

	@Override
	public void eat() {
		System.out.println("我是狗，我吃肉！");
	}

}

class Cat extends Animal {

	@Override
	public void eat() {
		System.out.println("我是猫，我吃鱼");
	}

}

class Bird extends Animal {

	@Override
	public void eat() {
		System.out.println("我是鸟，我吃虫子。");
	}

}

public class Test {
	public static void main(String[] args) {
		/* 创建对象数组 */
		Animal[] animals = { new Dog(), new Cat(), new Bird() };
		for (Animal animal : animals) {
			animal.eat();
			animal.sleep();
		}
	}
}

运行结果：

我是狗，我吃肉！
动物睡觉！
我是猫，我吃鱼
动物睡觉！
我是鸟，我吃虫子。
动物睡觉！

对象的多态性中调用的是被子类覆写的方法。

方法参数的多态性

public class Test {
	public static void main(String[] args) {
		/* 创建对象数组 */
		Animal[] animals = { new Dog(), new Cat(), new Bird() };
		for (Animal animal : animals) {
			fun(animal);
		}
	}
	
	/*方法参数的多态*/
	public static void fun(Animal animal){
		animal.eat();
	}
}

运行结果：

我是狗，我吃肉！
我是猫，我吃鱼
我是鸟，我吃虫子。

执行各自的eat（）方法。