java多态的特点、多态中的类型转换、多态中的优缺点

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

---

前言

多态的概述（ polymorphic ）
• 定义：某一类事物的多种存在形态。
• 动态绑定：是指“在执行期间”（而非编译期间）判断所引用对象的实际类型，根据实际类型调用相应的方法。

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、多态的体现和前提

程序中体现：父类或者接口的引用指向或者接收自己的子类对象。
• 多态三个必要条件：
– 父类或者接口的引用指向子类对象
– 要有覆盖操作，也就是重写
– 需要存在继承或者实现关系

二、多态的成员特点

• 成员变量：
– 编译时期:看的是引用型变量所属的类中是否有所调用的变量
– 运行时期:也是看引用型变量所属的类是否有调用的变量
– 成员变量无论编译还是运行都看引用型变量所属的类,简单记成员变量,编译和运行都看等号左边
• 成员函数：
– 编译时：要查看引用变量所属的类中是否有所调用的成员。
– 在运行时：要查看对象所属的类中是否有所调用的成员。如果父子出现同名的方法,会运行子类中的方法,因为方法有覆盖的特性
– 编译看左边运行看右边
• 静态函数:
– 编译时期:看的引用型变量所属的类中是否有所调用的变量
– 运行时期:也是看引用型变量所属的类是否有调用的变量
– 编译和运行都看等号左边
即
成员变量 编译时看的是左边，运行时看的左边
成员方法 编译时看的是左边，运行时看右边
静态方法 编译时看的是左边，运行时看的也是左边
编译时看的都是左边，运行时成员方法看的是右边，其他（成员变量和静态的方法）看的都是左边

public class PoymorphicDemo2 {
	public static void main(String[] args) {
		Dad d = new Kid();
		System.out.println(d.num);//20
		d.method();	//我是子类方法
		d.function();//我是父类静态方法
		//使用变量去调用静态方法，其实相当于用变量类型的类名去调用
		//即Dad.function();//我是父类静态方法
	}
}
class Dad {
	int num = 20;
	public void method() {
		System.out.println("我是父类方法");
	}
	public static void function() {
		System.out.println("我是父类静态方法");
	}
}
class Kid extends Dad {
	int num = 10;
	public void method() {
		System.out.println("我是子类方法");
	}
	public static void function() {
		System.out.println("我是子类静态方法");
	}
}

三、多态中的类型转换

多态中的向上转型和向下转型:

• 引用类型之间的转换
  • 向上转型
  – 子类转型成父类型
  – Animal a = new Dog();
  • 向下转型
  – 父类型转型成子类型
  – Dog d = (Dog)a;
• 基本数据类型的转换
  自动类型转换-----由小到大
  byte short char — int — long — float — double
  强制类型转换-----由大到小
  • int b = 2;
  • char a = (char)b;

public class zhuanghuan{
	public static void main(String[] args) {
		Animal2 a = new Dog();	//向上转型
		a.eat();				//啃骨头
		//a.swim();				//不行，虽说实际指向Dog类，但Animal2没有swim()方法
		
		Dog d = (Dog) a;		//强制转换，向下转型
		d.swim();				//狗刨
		
		/*Animal2 a = new Animal2();
		Dog d = (Dog) a;
		d.eat();*///编译没报错，但是运行时报错了，报Animal2不可以转换成Dog，不可以随意软转换，需要本质上就是这种类，才可以转换
	}
}
class Animal2 {
	public void eat() {
		System.out.println("吃东西");
	}
}
class Dog extends Animal2 {
	public void eat() {
		System.out.println("啃骨头");
	}
	public void swim() {
		System.out.println("狗刨");
	}
}

四、多态中的优缺点

优点：可以提高可维护性（多态前提所保证的），提高代码的可扩展性
缺点：无法直接访问子类特有的成员

public class PoymorphicDemo4 {
	public static void main(String[] args) {
		MiFactory factory = new MiFactory();
		factory.make(new NoteMi());
		factory.make(new RedMi());
		factory.make(new HeiMi());
	}
}

class MiFactory{
	/*	public void make(NoteMi p) {
			p.call();
		}
		
		public void make(RedMi p) {
			p.call();
		}
		
		public void make(HeiMi p) {
			p.call();
		}*/接口实现，通过多态，因为接口也有call()方法
	public void make(Phone p) {
		p.call();
	}
}

interface Phone{
	public void call();
}
class NoteMi implements Phone{
	public void call() {
		System.out.println("NoteMi打电话");
	}
}
class RedMi implements Phone{
	public void call() {
		System.out.println("RedMi打电话");
	}
}
class HeiMi implements Phone{
	public void call() {
		System.out.println("HeiMi打电话");
	}
}

---