向上转型和向下转型

Posted 2021-02-20 ct-debug

Java转型记住一句话：父类引用指向子类对象。

父类引用指向子类对象

向上转型

Father f1 = new Son();
//向上转型不用强制转换,将子类对象转为父类对象,父类对象可以是接口。
// 现在 f1 引用指向一个Son对象

向下转型

Son s1 = (Son)f1;
//指向子类对象的父类引用赋给子类引用叫向下转型,要强制转换,与向上转型相反，即是把父类对象转为子类对象。
//f1 就是一个指向子类对象的父类引用。把f1赋给子类引用 s1 即 Son s1 = (Son)f1;
//其中 f1 前面的(Son)必须加上，进行强制转换。

父类引用能指向子类对象，而子类引用不能指向父类对象

Father f2 = new Father();
Son s2 = (Son)f2;
//出错，父类引用能指向子类对象，而子类引用不能指向父类对象

实例代码：

package case2;

import java.util.Scanner;

public class Task2 {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		String cName = sc.next();
		String cSex = sc.next();
		int cAge = sc.nextInt();
		String eName = sc.next();
		String eSex = sc.next();
		int eAge = sc.nextInt();
		// 创建测试类对象test
		// 创建Person类对象person1,引用指向中国人,通过有参构造函数实例化中国人类对象
		// 通过showEat()方法调用Chinese的eat()方法
		// 创建Person类对象person2,引用指向英国人,通过有参构造函数实例化英国人类对象
		// 通过showEat()方法调用English的eat()方法
		/********* begin *********/
        Person person1 = new Chinese(cName,cSex,cAge);
		person1.eat();//此处将调用子类的eat()方法。原因：person1实际指向的是Chinese子类，故调用时会调用子类本身的方法。
        //需要注意的是向上转型时person1会遗失除与父类对象共有的其他方法。如本例中的shadowBoxing()方法不再为person1所有。
		System.out.println("--------------------------");
		showEat(person1);
		Person person2 = new English(eName,eSex,eAge);
		person2.eat();
		System.out.println("--------------------------");
		showEat(person2);
		/********* end *********/
		// 强制类型转换(向下转型) 调用Chinese类特有的方法shadowBoxing()
		// 强制类型转换(向下转型) 调用English类特有的方法horseRiding()
		/********* begin *********/
        Chinese c = (Chinese) person1;
		c.shadowBoxing();
		English e = (English) person2;
		e.horseRiding();
		/********* end *********/
	}

	// 定义showEat方法，使用父类作为方法的形参，实现多态，传入的是哪个具体对象就调用哪个对象的eat()方法
	/********* begin *********/
    public static void showEat(Person p){
		p.eat();
	}
	//这里以父类引用为参数,利用了向上转型,传入的是哪个具体对象就调用哪个对象的eat()方法,体现了JAVA的抽象编程思想。
	/********* end *********/
}

// 抽象类Person 封装属性name、sex和age
// 构造函数初始化name、sex和age
// 声明抽象方法eat()
abstract class Person {
	/********* begin *********/
    public abstract void eat();
	String name;
	String sex;
	int age;
	/********* end *********/
}

// Chinese类继承自Person类
// 构造函数初始化name、sex和age
// 重写父类方法eat() 输出‘姓名：name，性别：sex，年龄：age，我是中国人，我喜欢吃饭！‘
// 定义子类特有方法shadowBoxing(),当父类引用指向子类对象时无法调用该方法 输出‘name在练习太极拳！‘
class Chinese extends Person {
	/********* begin *********/
	public Chinese(String n,String s,int a){
		name = n;
		sex = s;
		age = a;
	}
    public void eat(){
        System.out.println("姓名："+name+"，性别："+sex+"，年龄："+age+"，我是中国人，我喜欢吃饭！");
	}
	public void shadowBoxing(){
		System.out.println(name+"在练习太极拳！");
	}
	/********* end *********/
}

// English类继承自Person类
// 构造函数初始化name、sex和age
// 重写父类方法eat() 输出‘姓名：name，性别：sex，年龄：age，我是英国人，我喜欢吃三明治!‘
// 定义子类特有方法horseRiding(),当父类引用指向子类对象时无法调用该方法 输出‘name在练习骑马！‘
class English extends Person {
	/********* begin *********/
	public English(String n,String s,int a){
		name = n;
		sex = s;
		age = a;
	}
    public void eat(){
        System.out.println("姓名："+name+"，性别："+sex+"，年龄："+age+"，我是英国人，我喜欢吃三明治！");
	}
	public void horseRiding(){
		System.out.println(name+"在练习骑马！");
	}
	/********* end *********/
}