初学这个对象的上转型对象，就有一个很奇怪的问题，这玩意有什么用？百度了很多资料，都是说的“可以简化代码”，但这“简化代码”是实在没看明白。这玩意不还是一样要给子类定义方法体重写父类的方法，然后new();创建对象调用相应方法。

想了好久，终于是想明白了，打个情景 “非诚勿扰”的嘉宾要在舞台发言。

class One {
    void say() {
        System.out.println("我是一号");
    }
}

class Two {
    void say() {
        System.out.println("我是二号");
    }
}

class Whoami {
    void who(One one) {
        one.say();
    }
    void who(Two two) {
        two.say();
    }
}

public class T5 {
    public static void main(String[] args) {
        One a = new One();
        Two b = new Two();
        Whoami i = new Whoami();
        i.who(a);
        i.who(b);
    }
}

//我是一号
//我是二号

Whoani类就像是一个舞台，每个嘉宾都要上去介绍自己，所以呢这里用了方法的重载，来识别输入的对应参数。这里只有2个嘉宾，所以仅仅只是需要2个重载方法。但如果有100个嘉宾呢？那难道要重载100个who()方法？那就太麻烦了，所以这就需要用到对象的上转型对象了，我们把One，Two继承到一个Guest类中，然后再对两个对象进行向上转型。

class Guest {
    void say() {}
}

class One extends Guest {
    void say() {
        System.out.println("我是一号");
    }
}

class Two extends Guest {
    void say() {
        System.out.println("我是二号");
    }
}

class Whoami {
    void who(Guest guest) {
        guest.say();
    }
}

public class T5 {
    public static void main(String[] args) {
        Guest a = new One();
        Guest b = new Two();
        Whoami i = new Whoami();
        i.who(a);
        i.who(b);
    }
}

//我是一号
//我是二号

因为上台介绍的都是嘉宾，所以我们把他们的共同行为封装成一个类，再对其进行继承重写。因为上转型对象的特殊性，我们就可以通过上转型对象调用子类重写的方法，这就缩减了不必要的重载方法。

然后，接着节奏走，这里是我踩的第二个坑。

class Guest {}

class One extends Guest {}

class Two extends Guest {}

class Whoami {
    void who (Guest guest) {
        System.out.println("我是嘉宾");
    }
    void who (One one) {
        System.out.println("我是一号");
    }
    void who (Two two) {
        System.out.println("我是二号");
    }
}

public class T5 {
    public static void main(String[] args) {
        Guest a = new One();
        Guest b = new Two();
        Whoami i = new Whoami();
        i.who(a);
        i.who(b);
    }
}

我一开始觉得这样写，输出的答案应该和前面的是一样的，但仔细一看这里新建的a和b对象是上转型对象。前面的静态属性是Guest，所以重载的方法调用的是

void who (Guest guest) {
    System.out.println("我是嘉宾");
}

所以这里输出的是两个“我是嘉宾”，贼坑。我问了个小伙伴，也被这坑了

2022.3.19补充

还是看不懂可以看看这个数据类型的上转型

public class T5 {
        //返回数据类型
    public static String getType(Object test) {
        return test.getClass().getName().toString();

    }

    public static void main(String[] args) {
        int a = 0;
        long b = 1;
        b = a;
        System.out.print(b);
        System.out.println(getType(b));
    }
}

//0
//java.lang.Long

仅仅是把a的值赋给了b，b的类型是不会发生改变的。

2022.03.26

学了抽象类，感觉这个题目又能改一下了。

abstract class Guest {}

class One extends Guest {}

class Two extends Guest {}

class Whoami {
    void who (Guest guest) {
        System.out.println("我是嘉宾");
    }
    /*void who (One one) {
        System.out.println("我是一号");
    }*/
    void who (Two two) {
        System.out.println("我是二号");
    }
}

public class Text1 {
    public static void main(String[] args) {
        One a = new One();
        Guest b = new Two();
        Whoami i = new Whoami();
        i.who(a);
        i.who(b);
    }
}

奇怪的知识又涨了。这个我的理解是方法重载机制的选择。