如何使超类中的某些方法在子类中不可用

Question

假设我有课

public class Base {}

还有儿童班

public class Derived extends Base {

    public void Foo(Object i){
        System.out.println("derived - object");
    }
}

和主课

public class Main {
    public static void main(String[] args) {
        Derived d = new Derived();
        int i = 5;
        d.Foo(i);
    }
}

在控制台中我们会看到 派生-对象

一段时间后，我想像这样修改我的超类：

public class Base {

    public void Foo(int i) {
        System.out.println("base - int");
    }
}

现在，如果我运行我的程序，我会看到：

base - int

那么我可以在超类中创建一个在我的子类中不可用的方法吗？ 结果我想看到派生-对象。

我看到有些人不明白我想要什么，所以我会尝试解释：

我只想修改超类，而不想修改我的子类..例如，如果我将用我的超类制作 jar 并用我的孩子制作 jar 。我不想更改所有罐子..我想将方法添加到超类中并使其可用于超类.. 还有这样的代码

    public class Main {
    public static void main(String[] args) {
        Derived d = new Derived();
        int i = 5;
        d.Foo(i);
        Base b = new Base();
        b.Foo(i);
    }
}

给我

派生-对象 基数 - int

Answer 1

您应该对基类中的

Foo

方法使用以下签名：

public void Foo(Object i) {
    System.out.println("base - int");
}

这样你就可以从基类重写方法

Foo

。现在您不必重写此方法，而是重载它。

如果您想在基类中使用

public void Foo(int i)

签名，那么您可以在基类中将

Foo

方法定义为

private

。

PS：我希望我能理解你。

Answer 2

• private成员仅限于类范围。
• default（此选项没有关键字）仅限于同一包的其他成员。
• protected 仅限于层次结构。
• 公众不限。

因此，如果您不希望子类访问超类的成员（成员意味着方法、枚举、变量...），您应该像这样声明您的 foo :

public class Base {

    private void Foo(int i) {
        System.out.println("base - int");
    }
}

编辑我的评论： 如果您不希望子类在编译时访问父类的成员，我看不到任何方法仍然允许外部类访问它。 您希望阻止近距离范围内的访问，同时允许更广泛的范围。这只能通过重写该方法并抛出访问冲突异常或不在编译时而是在运行时的异常来完成。虽然你可以让它与自定义注释一起工作，但我不知道如何做到这一点。

Answer 3

你可以将一个方法设为final，这意味着子类不能重写它。

如果您不这样做并且子类重写了该方法，则您无法从 main 中调用超类方法。

约定注意事项：请在java中使用小写的方法名称。

Answer 4

package com.abc;


public class TestParentChild {

    public static void main(String[] asd) {
        Base b = new ChildB();
        b.foo(5);
    }
}

class Base {
    public void foo(int i) {
        System.out.println("derived - int");
    }

}

class ChildB extends Base {
    public void foo(int i) {
        System.out.println("derived - object");
    }
}

这可能对你有帮助

Answer 5

您可以在Java中使用

@Override

注释。当子类中重写方法时，对于子类的实例，子类方法优先于超类方法。

以下是修改代码的方法：

public class Base {
    public void Foo(Object i) {
        System.out.println("base - object");
    }
}

public class Derived extends Base {
    @Override
    public void Foo(Object i) {
        System.out.println("derived - object");
    }
}

public class Main {
    public static void main(String[] args) {
        Derived d = new Derived();
        int i = 5;
        d.Foo(i); // Output: derived - object
        Base b = new Base();
        b.Foo(i); // Output: base - object
    }
}

在此示例中，

Foo(Object i)

方法在

Base

类中定义。

Derived

类使用

@Override

注释重写此方法，并且当在

Foo

实例上调用

Derived

方法时，将使用其实现。

当您运行

Main

类时，输出将是：

derived - object
base - object

对

d.Foo(i)

的第一次调用会调用

Derived

类中的重写方法，因为

d

是

Derived

的实例。第二次调用

b.Foo(i)

会调用

Base

类中的方法，因为

b

是

Base

的实例。

通过使用

@Override

注释，您可以确保子类实例的子类方法优先于超类方法，即使您稍后在超类中添加或修改方法也是如此。这样，您就不需要修改子类或包含子类的 JAR 文件。

请注意，如果您想向

Foo(int i)

类添加具有不同签名（例如

Base

）的新方法，它不会与

Derived

类中重写的方法冲突，并且两种方法都可用为各自的班级。