compareTo和隐式类型转换的参数 import java.util.*； 公营雇员 { 私有内部empId； 私有字符串名称； 私人互联网； 公共雇员（字符串名称、整数id、整数年龄） { this.name=名称； this.empId=id； 这个。年龄=年龄； } 公共int getId（） { 返回empId； } 公共整数getAge（） { 回归年龄； } 公共字符串getName（） { 返回名称； } } 类SortById扩展了Employee实现 { 公共SortById（字符串名称、整型id、整型年龄） { 超级（姓名、身份证、年龄）； } 公共内部比较（排序其他） { if（this.getId（）>other.getId（））返回1； if（this.getId（）0）返回1； if（this.getName（）.compareTo（other.getName（））

这个程序运行得很好，我只是想问，因为我使用的是

Comparable

的参数化版本，我传递到

compareTo

的引用应该是

SortById

类型还是

SortByName

类型

即使引用的类型为

Employee

，代码也可以正常运行，尽管它指向它的子类（

SortByName

或

SortById

）

---

隐性演员阵容是如何发生的？我已经读过不可能，也就是说，不可能隐式地将超类类型转换为子类。

您从不调用

compareTo

，这解释了为什么您不需要转换。实际调用在

数组中。排序

由谁来处理（通过实际使用原始

可比

）

此外，在这种情况下，编译器将生成2个

compareTo

方法：一个是使用

SortByXX

参数显式定义的方法，另一个是使用委托给第一个方法的

对象

参数定义的方法

---

正如@martijno所说，如果在数组中添加一个简单的

员工

，您将遇到问题，这将导致

ClassCastException

（从

员工

到

可比

或

SortByXX

）。如果将

SortByName

和

SortById

混合使用，则数组中的所有

Employee

实例都具有实际类型

SortById

或

SortByName

，则会发生相同的情况。如果向数组中添加一个

新雇员（String，int，int）

，就会出现错误。JVM在运行时确定对象的真实类型。因为您是通过

new SortByName（）

创建它们的，所以JVM知道它是正确的类型，即使您将引用作为Employee@jalynn2隐式转换不是在这里发生吗？所以对象类型很重要，而不是引用类型（在这种情况下它可能是超级/子类），并且在compareTo方法的内部实现期间发生（正如您所说的，它会处理），在传入之前，自动将其强制转换到其子类中，因为您是对的，当我自己调用compareTo方法时，它产生了一个错误。变量（或表达式）类型在编译时很重要，只要您调用该方法！如果您使用（允许）显式强制转换，则将在运行时检查对象类型。生成的

compareTo（对象）

确实执行显式强制转换以委托给

compareTo（SortByXX）

。

import java.util.*;

public class Employee
{
    private int empId;
    private String name;
    private int age;
    public Employee(String name, int id, int age )
    {
        this.name = name;
        this.empId = id;
        this.age = age;
    }
    public int getId()
    {
        return empId;
    }
    public int getAge()
    {
        return age;
    }
    public String getName()
    {
        return name;
    }

}

class SortById extends Employee implements Comparable<SortById>
{
    public SortById(String name, int id, int age)
    {
        super(name, id, age);
    }
    public int compareTo(SortById other)
    {
        if (this.getId() > other.getId()) return 1;
        if (this.getId() < other.getId()) return -1;
        return 0;

    }
}

class SortByName extends Employee implements Comparable<SortByName>
{
    public SortByName(String name, int id, int age)
    {
        super(name, id, age);
    }

    public int compareTo(SortByName other)
    {
        if (this.getName().compareTo(other.getName()) > 0) return 1;
        if (this.getName().compareTo(other.getName()) < 0) return -1;
        return 0;

    }
}

class Test
{
    public static void main(String args[])
    {
        Employee[] array = new SortById[3];
        array[0] = new SortById("Gautam", 1222, 20);
        array[1] = new SortById("Shivam", 1221, 20);
        array[2] = new SortById("Ankit", 1223, 21);
        System.out.println(array[0] instanceof SortByName);

        Arrays.sort(array);
        for (int i = 0; i < array.length; i++)
            System.out.println("ID: " + array[i].getId() + " Name: " + array[i].getName() + " Age: " + array[i].getAge());
        Employee[] array2 = new SortByName[3];
        array2[0] = new SortByName("Gautam", 1222, 20);
        array2[1] = new SortByName("Shivam", 1221, 20);
        array2[2] = new SortByName("Ankit", 1223, 21);
        Arrays.sort(array2);
        for (int i = 0; i < array2.length; i++)
            System.out.println("ID: " + array2[i].getId() + " Name: " + array2[i].getName() + " Age: " + array2[i].getAge());

    }
}