2022.0520学习Java笔记之对象多态性

如果说继承性是为了解决代码重用问题，那么多态性就是为了就是为了解决参数同一问题，而且多态一定结合继承关系后才可使用，

所谓多态性是指父子对象之间的转换操作，那么多态性一共有两种转换形式：

• 向上转型 ： 父类 父类对象 = 子类实例        自动完成转换
• 向下转型 ： 子类 子类对象 = (子类)父类实例        强制转换

例如：

class Person{
	public void print(){
		System.out.println("1.Person类，");
	}
}
class Student extends Person{
	public void print(){
		System.out.println("2.Student类，");
	}
	public void fun(){
		System.out.println("3.Student类，fun方法");
	}
}
public class TextDemo11{
	public static void main(String args[]){
		Person per = new Student();	//向上转型，自动转换
		per.print();
		Student stu = (Student)per;	//向下转型，强制转换
		stu.fun();
	}
}

 

总结：

• 向上转型主要特征：子类为父类对象实例化，调用的方法一定是子类所覆写过的方法。向上转型是找父子类共性
• 向下转型主要特征：子类扩充了某些功能，而这些功能夫类之中没有定义，则需要向下转型，以调用子类特有功能。向下转型是找特性。

在程序之中，父类并不知道自己有哪些子类，但是子类知道自己的父类是谁，所以要发生向下转型之前，必须首先建立好父子类之间的关系（向上转型），而后才可以向下转型。

为安全进行转型操作，在Java 之中提供了instanceof关键字，利用此关键字就可以判断某一个对象是否时某一个类的实例，语法：对象 instanceof 类        返回boolean型数据        

实例

class Person{
	public void print(){
		System.out.println("1.Person类，");
	}
}
class Student extends Person{
	public void print(){
		System.out.println("2.Student类，");
	}
	public void fun(){
		System.out.println("3.Student类，fun方法");
	}
}
public class TextDemo11{
	public static void main(String args[]){
		Person per = new Student();	//向上转型，自动转换
		System.out.println(per instanceof Person);
		System.out.println(per instanceof Student);	
		if(per instanceof Student){
			Student stu = (Student)per;
			stu.fun();
		}
	}
}

运行结果

 

 相互转型的意义

如果现在有一个程序，其中Person类下有学生、工人、老师三个子类，现在要求不同人说不一样的话，要求定义一个方法，可以接收Person类中的所有引用。

实现一，利用方法重载

class Person{
	public void say(){
		System.out.println("1.我是一个人");
	}
}
class Student extends Person{
	public void say(){
		System.out.println("2.我是一个学生");
	}
}
class Worker extends Person{
	public void say(){
		System.out.println("3.我是一个工人");
	}
}
class Teacher extends Person{
	public void say(){
		System.out.println("4.我是一个老师");
	}
}
public class TextDemo11{
	public static void main(String args[]){
		fun(new Student());
		fun(new Worker());
		fun(new Teacher());
	}
	public static void fun(Student stu){
		stu.say();
	}
	public static void fun(Worker wrk){
		wrk.say();
	}
	public static void fun(Teacher tea){
		tea.say();
	}
}

 

 

实现二：利用对象向上转型

对象在进行向上转型时可以自动完成父类接收子类的功能，同时转型之后所调用的方法也一定是随实例化子类的不同，同一个方法一定执行不同的功能

public class TextDemo11{
	public static void main(String args[]){
		fun(new Student());
		fun(new Worker());
		fun(new Teacher());
	}
	public static void fun(Person per){
		per.say();
	}
}

结果也是一样，并且如果现在随意去扩充子类，fun方法不需要做任何改动就可以满足所有功能

例题

现在假设有一个数组操作类，这个类操作之中需要接收一个数组（通过构造传递），而后在此类下有两个子类，一个子类在获取数据的时候会将传入的数据进行排序后返回，另一个子类会将传递进去的数据以反转的形式返回。

 

class Arry{
	private int data[];//保存数组
	public Arry(int data[]){
		this.data = data;//构造方法传递数组
	}
	public int[] getData(){
		return this.data;
	}
}
class SortArry extends Arry{
	public SortArry(int data[]){
		super(data);
	}
	public int[] getData(){
		java.util.Arrays.sort(super.getData());//排序
		return super.getData();
	}
}
class ReverseArry extends Arry{
	public ReverseArry(int data[]){
		super(data);
	}
	public int[] getData(){
		int center = super.getData().length/2;
		int herd = 0;
		int tail = super.getData().length-1;
		for(int x = 0; x < center; x++){
			int temp = super.getData()[herd];
			super.getData()[herd] = super.getData()[tail];
			super.getData()[tail] = temp;
			herd++;
			tail--;
		}
		return super.getData();
	}
}
public class TextDemo11{
	public static void main(String args[]){
		Arry arr = new ReverseArry(new int[] {5,6,7,1,2,3});
		print(arr);
	}
	public static void print(Arry temp){
		int result[] = temp.getData();
		for(int x = 0; x<result.length; x++){
			System.out.print(result[x] + "、");
		}
	}
}

总结：关于继承性与多态

• 这两特性一定是相辅相成，不可以缺一
• 继承性解决的时一个类功能扩充的问题，而多态性解决的是参数同一问题，有了多态之后应该发觉，父类的设计是相当重要的，而且子类里面不要轻易扩充父类里面没有的方法，要按照父类已有的方法规格覆写方法。 

关于对象转型问题

• 向上转型（90%）：自动完成，子类对象自动转化为父类对象，而后调用的是子类所覆写过的方法，利用对象的向上转型就可以很好解决参数同一问题。
• 向下转型（1%）：强制完成，不建议出现，当需要调用子类自己扩充的方法的时候。
• 不转型（9%）：很多时候的一些类是不会进行转型操作，如String。