向下转型的理解

什么是多态？（向下转型意义的理解）

专业角度：同种类的多个对象，在接收到同一个消息时却产生了不同反应和效果；

从代码形式上看: 父类的对象变量调用了子类中重写的方法（注意: 往往是有一个父类，而他有多个子类，且在这些子类中同时重写父类的某个方法）；

举例：

• 酒 a = 剑南春

• 酒 b = 牛栏山

• 酒 c = 酱香科技

  • 上面例子中，“酒”是父类，具体酒的品牌都是“酒”这个大类的孩子，我们只是通过酒这一个父类就能够引用不同的子类，这就是多态

class Father{
	private String name;
	private int age;

	public Father(){}

	public Father(String name,int age){
		this.name = name;
		this.age = age;
	}

	public void say(){
		System.out.println("I am your father!");
	}

	public String getName(){
		return name;
	}

}

class Son extends Father{

	public Son(String name,int age){
		super(name,age);
	}
	public Son(){

	}

	// 如果父类中的属性已经赋值的话，子类中是可以通过get方法获得父类的私有属性的
	public void fathername(){
		System.out.println("My father is " + super.getName());
	}

	public void say(){
		System.out.println("I am Son");
	}

	public void power(){
		System.out.println("I will powerful than father!");

	}
}

1. 向上转型

格式： 父类 变量名 = new 子类（）；

public class toUpDemo{
	public static void main(String[] args){

		// 向上转型  父类 父 = 子类实例
		Son son = new Son("lgt",23);
		Father father = son;
		father.say();
		// father.power();  父类即使转型也无法调用子类独有的方法

	}
}


输出结果： I am Son

总结：

向上转型存在一些缺憾，转型之后，因为操作的是父类对象，所以对于子类中定义的新方法（子类特有的）是找不到的

2. 向下转型

//子类 子 = 父类实例

		Father father = new Father("xxx",23);
		Son son = father;
		son.say();

输出：
    
    toDownDemo.java:52: 错误: 不兼容的类型: Father无法转换为Son
                Son son = father;
                          ^
1 个错误

• 显然直接照搬上面的写法是行不通的

• 向下转型必须向上转型，之后再进行强制转化，向下转型

  Father father = new Son("xxx",99);//先向上转型
  		Son son = (Son)father;
  		son.say();
  

思考： 为什么要向下转型？（重要）

• 子类实例对象，先是生成子类实例赋值给父类引用，在将父类引用向下强转给子类引用，这不是脱裤子放屁吗，直接不转型用子类实例不就可以了吗？这么做的意义到底是什么？

>>看这个例子你就知道向下转型的作用了！

• 首先有一个 Electronics "电子产品"的抽象类，现在给他生三个孩子，分别 Laptop（手提电脑）、Camera（相机）、Gameplayer（游戏机）
• Electronics 中有一个抽象方法，就是Type （商品品类），各个孩子都有一个区别于父类的方法 Function（功能）

package com.lgt.Demo5;

import java.sql.SQLOutput;
import java.util.ArrayList;
import java.util.List;


//电子产品抽象类
abstract class Electronics{
    private String name;
    private float price;

    public Electronics(String name, float price) {
        this.name = name;
        this.price = price;
    }

    public String getName() {
        return name;
    }

    public float getPrice() {
        return price;
    }

    //商品类别
    public abstract void type();
}

// 电脑类
class Laptop extends Electronics{
    public Laptop(String name, float price) {
        super(name, price);
    }

    @Override
    public void type() {
        System.out.println("Type:  Person Laptop");
    }

    public void function(){
        System.out.println("Function： 媒体编辑、程序开发、娱乐、网上冲浪");
    }
}

//相机类
class Camera extends Electronics{

    public Camera(String name,float price){
        super(name, price);
    }
    @Override
    public void type() {
        System.out.println("Type:  Professional Camera");
    }

    public void function(){
        System.out.println("Function： 拍照、vlog拍摄");
    }
}

//游戏设备
class GamePlayer extends Electronics{
    public GamePlayer(String name,float price){
        super(name, price);
    }

    @Override
    public void type() {
        System.out.println("Type:  GamePlayer");
    }

    public void function(){
        System.out.println("Function： 游戏娱乐");
    }
}

新建一个类： Mypossession（我的物品）

• 用一个泛型数组存放所有的具体电子产品

//我的物品
class MyPossession{
    private List<Electronics> mylist = new ArrayList<Electronics>();

    public void add(Electronics electronics){
        mylist.add(electronics);
    }

    public int getListLentgh(){
        return mylist.size();
    }

    public Electronics getListItem(int flat){
        return mylist.get(flat);
    }

}

需求：

我要在测试类中打印出我每一个物品的 类型名称、价格还有其各自的功能（Function）。

前面的三项都不重要，关注后面的Function

分析：在将电脑、相机和游戏机的实例存放在一个集合中时，为了防止类型不统一的麻烦，这里使用了泛型,统一以它们的父类类型 “Electronics” 来接收，这里就相当于是一个向上转型；通过向上转型，我们成功将不同类型的实例放在一个泛型集合中储存，但也有一个问题随之而来，因为向上转型是把父类引用指向了子类实例，这样我们在后续操作时使用的是父类对象，因此我们无法调用子类独有的 Function方法

public class MyTest {
    public static void main(String[] args) {
        Laptop laptop = new Laptop("Macbook Pro",12229);
        Camera camera = new Camera("Z6",10999);
        GamePlayer gamePlayer = new GamePlayer("Xbox",2999);
        MyPossession myPossession = new MyPossession();
        myPossession.add(laptop);
        myPossession.add(camera);
        myPossession.add(gamePlayer);

        for(int i=0;i<myPossession.getListLentgh();i++){
            myPossession.getListItem(i).type();
            System.out.println("Name:  "+myPossession.getListItem(i).getName());
            System.out.println("Price:  "+myPossession.getListItem(i).getPrice());
            //myPossession.getListItem(i).function();  必定报错，此处如果要获取个具体电子产品类中的function方法是不可行的
            
            //向下转型  格式：子类 引用变量名 = （子类）父类实例 
            if(myPossession.getListItem(i) instanceof Laptop){
                ((Laptop) myPossession.getListItem(i)).function();
            }
            else if(myPossession.getListItem(i) instanceof Camera){
                ((Camera) myPossession.getListItem(i)).function();
            }
            else{
                ((GamePlayer) myPossession.getListItem(i)).function();
            }
            System.out.println(">>-------------------");
        }
    }
}

((Laptop) myPossession.getListItem(i)).function();

这里相当于对父类对象进行了向下转型，这样就可以正确调用 function方法了。

//输出
Type:  Person Laptop
Name:  Macbook Pro
Price:  12229.0
Function： 媒体编辑、程序开发、娱乐、网上冲浪
>>-------------------
Type:  Professional Camera
Name:  Z6
Price:  10999.0
Function： 拍照、vlog拍摄
>>-------------------
Type:  GamePlayer
Name:  Xbox
Price:  2999.0
Function： 游戏娱乐
>>-------------------

Process finished with exit code 0

总结：

不管是向上还是向下转型，都是为了灵活的应对程序设计中的类的多样性问题；

向上转型，实现了通过一个父类对象的引用，去引用多个子类，九九归一；

向下转型，更多的应用于泛型编程、集合等类型复杂多样的场景