java中重写方法约束

java中的重写方法具有以下特性：

1> Overriding方法应该与父类方法具有相同的参数列表

2> 返回类型应与父类方法的返回类型相同/子类

3> 访问级别应与父类方法相同或限制较少

4> 重写的方法可以抛出相同或更窄的异常，而不是更宽的异常

*只是想知道为什么point*

*2-为什么子类不是超类？*

3-为什么访问级别的限制性应该更小？

4-为什么它应该抛出狭义异常？

根据我的理解，如果我创建父类引用来创建子类对象，并尝试运行每个场景，那么

假设A是父类，B是子类，两者都有方法print和returnsomething（）

现在我们有了B班的孩子

public class B extends A{
       public A printAndReturnSomething(){ // I know this isn't possible to return A but had it been then
                S.O.P("Inside A Print");
                return new A();
              }
}

现在如果我做这样的事

A a =new B();

现在我有一个a的引用，所以我希望返回类型是B

B returnedValue=a.printAndReturnSomething(); // But it actually calls the child class method and hence returns A. So here comes the contradiction.

与场景3和4类似。我的理解正确吗？我是否遗漏了其他更相关的内容

第二点

想象一下：

class Animal {}
class Dog extends Animal {}

class Base {
    Dog get() { ... }
}

class Derived extends Base {
    Animal get() { ... }
}

Base b = new Derived();
Dog d = b.get(); // What?

---

类似的逻辑也适用于其他问题。

所有这些都可以用“子类的行为必须像超类一样”来概括。因此，如果

Derived

扩展

Base

并且我有一个

x

类型为

Derived

的对象，那么我希望它的行为与

Base

类型完全相同

因此，如果

x.foo（）

返回一些类型

T

，并且

Base:：foo（）

返回一个类型

S

，那么我希望能够将

x.foo（）

视为

S

，因此

T

最好与

S

相同或是

S

的子类

类似地，

x.foo（）

应该只抛出

Base:foo（）

承诺的异常。它无法开始抛出新的意外异常

如果

Base:：foo（）

是公共的，那么

x.foo（）

也应该是公共的。您不能突然对派生类有更严格的限制，因为基类向我保证它是公共的

始终将继承视为“行为类似于超类”，或者“可以被视为超类”，所有这些都应该是清楚的。

要回答您的问题：

2-为什么子类不是超类？

如果允许使用超类，则可能发生以下情况：

class A {
    public A makeCopy() { return clone(); }
}

class B extends A {
    public Object makeCopy() { return new Date(); }
}

public static void main(String[] args) {
    A a = new B();
    A copy = a.makeCopy(); // OOPS -- didn't get an A after all!
}

3-为什么访问级别的限制性应该更小？

将上述B类修改为：

class B extends A {
    private A makeCopy() { return clone(); }
}

public static void main(String[] args) {
    A a = new B();
    A copy = a.makeCopy(); // OOPS -- accessing a private method!
}

4-为什么它应该抛出狭义异常？

同样的想法——如果

A.makeCopy

被声明抛出一个

aeexception

（在

A

中声明的一个假设异常类），但是

B.makeCopy

被声明抛出

Throwable

，那么

B.makeCopy

几乎可以抛出任何东西。这样就不可能在

main

中合理地编写try/catch块

根据我的理解，如果我创建父类引用来创建子类对象，并尝试运行每个场景

我认为你的想法是正确的

---

父类引用子类对象的情况就是所谓的情况：在计算机程序中，如果S是T的子类型，那么T类型的对象[那是你的“父类”]可能会被S类型的对象[那是你的“子类对象”]所取代（也就是说，S类型的对象可能会被T类型的对象所取代），在不改变该程序的任何期望属性（正确性、执行的任务等）的情况下……

感谢您的回复。这一点我在问题中已经提到。我想检查的是这是唯一的原因吗？@Deva:这是一个非常基本的原因！这根本没有任何意义。感谢您的ans，尤其是最后一行“始终将继承视为“行为类似于超类”或“可以被视为超类”，所有这些都应该很清楚。”

class B extends A {
    private A makeCopy() { return clone(); }
}

public static void main(String[] args) {
    A a = new B();
    A copy = a.makeCopy(); // OOPS -- accessing a private method!
}