OOP Java：可以将子类返回给父类吗？

Question

我是 OOP 的新手，所以我有一个关于类何时扩展另一个类的愚蠢问题。

这是我的例子：

public class Test {
    public Monitor getMonitor(){
        return new LCD();
    }

    class LCD extends Monitor {   NO-ERROR
    class LCD {                   ERROR at line `return new LCD` 
        //some other method or function not in Monitor Class. Example:
        boolean isSamsung;
        public LCD whatkindLCD(){           
        }       
    }
}

我对上面的代码有一个问题：因为 LCD 是从 Monitor 扩展的，并且 LCD 有 Monitor 所做的一些其他属性/方法不是。那么，LCD 是 Monitor 的子级，对吧？

这意味着你试图把一个“大盒子”放在一个“小盒子”上。那么，为什么当我返回新的 LCD 时，Eclipse 不会像我只使用 class LCD { 时那样注意到错误。

谢谢 ：）

Answer 1

在第二种（错误）情况下，您忘记声明 LCD 实际上扩展了 Monitor。您只是定义了一个“正常”的独立类 - 因此 new LCD() 不是 Monitor 的实例。

如果您像这样声明 LCD 类，编译器应该会很高兴：

class LCD extends Monitor {
    //some other method or function not in Monitor Class. Example:
    boolean isSamsung;
    public LCD whatkindLCD(){           
    }       
}

---

Edit （回应评论）： LCD 根本不是问题与 Monitor 相比，code> 类具有额外的属性/方法。将调用 getMonitor() 的代码，只关心它是否获得 Monitor 返回 - 也就是说，具有 Monitor() 的所有方法、属性和行为的东西。代码>监视器。

因此，如果您的 Monitor 类上有 turnOff 和 displayBitmap(int[][] data) 方法，那么您的 LCD 类也会有这些方法。当需要时，LCD 的任何实例都可以充当 Monitor - 这是 OO 语言中子类化的基本原则。因此，每当需要 Monitor 时，您都可以给它一个 LCD，或者一个 CRT 或 SamsungLCD 实例如果你有这些，编译器可以确信正确的方法/属性将存在并且可以被调用。

（从技术上讲，如果您喜欢正式定义，那么这就是 里氏替换原则，但您不需要如此详细地理解它。）

Answer 2

盒子的类比是错误的，应该将其视为是关系。

在第一个示例中，LCD 扩展了 Monitor，即 LCD 是一个 Monitor，因此在任何需要 Monitor 的地方，LCD 都可以。当您考虑现实世界而不是查看代码时，您会意识到这是正确的。一般情况下，您可以期望显示器执行的所有操作（例如显示图片），液晶显示器都可以执行。

在第二个示例中，LCD 不是监视器，因此您会收到一条错误消息。

Answer 3

将继承理解为“是”关系。这是我在新手时期用来理解继承的一个简单例子。

class Employee
{
    String name;
    int salary;

    Employee()
    {
        name = "Employee";
        salary = 5000;
    }
    public String getName()
    {
        return name;
    }
    public int getSalary()
    {
        return salary;
    }
}
class Manager extends Employee
{
    int bonus;
    int salary;

    Manager()
    {
        bonus = 1000;
        salary = 6000;
    }
    public int getBonus()
    {
        return bonus;
    }
    public int getSalary()
    {
        return salary;
    }   
}

class Test
{        
    public static void main(String[] args)
    {
        Employee e = new Employee();
        System.out.println(e.getName());
        //System.out.println(e.getBonus());
        System.out.println(e.getSalary());

        System.out.println();

        Manager m = new Manager();
        System.out.println(m.getName());
        System.out.println(m.getBonus());
        System.out.println(m.getSalary());

        System.out.println();

        Employee em = new Manager();
        System.out.println(em.getName());                   
        //System.out.println(em.getBonus());            
        System.out.println(((Manager)em).getBonus());
        System.out.println(em.getSalary());     
        }
}

编译器在调用引用类型上的任何操作之前会查找引用类型。
em.getBonus() 不起作用，因为 Employee 没有奖金方法。
但使用演员表我们可以让它发挥作用。
((Manager)em.)getBonus()

编译器在调用引用类型上的任何操作之前查找引用类型的原因如下：

Manager[] Managers = new Manager[10];

将此数组转换为 Employee[] 数组是合法的：

Employee[] Staff = Managers; // 好吧

，当然，你可能会想为什么不呢。毕竟，如果 manager[i] 是经理，那么它也是员工。但实际上，令人惊讶的事情正在发生。请记住，经理和员工是对同一数组的引用。

现在考虑语句

Staff[0] = new Employee("John Eipe", ...);

编译器会很高兴地允许这个分配。
但是，staff[0] 和 manager[0] 是相同的引用，因此看起来我们似乎成功地将一名员工偷偷带入了管理层
行列。

这将是非常糟糕的——调用managers[0].setBonus(1000)会尝试访问
不存在的实例字段会损坏相邻的内存。
为了确保不会发生此类损坏，所有数组都会记住元素类型
它们被创建，并且它们监视仅兼容的引用被存储到
他们。例如，创建为 new Manager[10] 的数组会记住它是一个数组
经理。尝试存储 Employee 引用会导致 ArrayStoreException。

Answer 4

您的方法 getMonitor 返回“Monitor”类型。

当您使用监视器扩展您的 LCD 类时，您是在说 LCD 是一个监视器。
当您删除扩展时，LCD 类将变为普通类，而不是监视器类型。
如果您将 getMonitor 修改为

public LCD getMonitor(){
       // code here
}

错误就会消失。