重写Java中的私有方法

Question

正如此处简要描述的，在 Java 中重写私有方法是无效的，因为父方法类的私有方法是“自动最终的，并且对派生类隐藏”。我的问题主要是学术性的。

不允许父类的私有方法被“覆盖”（即，在子类中使用相同的签名独立实现），这怎么可能不违反封装性呢？父类的私有方法不能被子类访问或继承，符合封装原则。它是隐藏的。

那么，为什么要限制子类实现具有相同名称/签名的自己的方法呢？这是否有良好的理论基础，或者这只是某种实用的解决方案？其他语言（C++ 或 C#）对此有不同的规则吗？

Answer 1

您不能重写私有方法，但可以在派生类中引入私有方法，而不会出现问题。编译正常：

class Base
{
   private void foo()
   {
   }
}

class Child extends Base
{
    private void foo()
    {
    }
}

请注意，如果您尝试将 @Override 注释应用于 Child.foo()，您将收到编译时错误。只要您将编译器/IDE 设置为在缺少 @Override 注释时向您发出警告或错误，一切都应该没问题。诚然，我更喜欢使用 override 作为关键字的 C# 方法，但在 Java 中这样做显然为时已晚。

至于C#对“重写”私有方法的处理——私有方法首先不能是虚拟的，但你当然可以引入一个与基类中的私有方法同名的新私有方法。

Answer 2

那么，允许重写私有方法要么会导致封装泄漏，要么会带来安全风险。如果我们假设这是可能，那么我们会得到以下情况：

1. 假设有一个私有方法boolean hasCredentials()，那么扩展类可以只需像这样覆盖它：

   boolean hasCredentials() { return true; } }
   

   从而破坏安全检查。

2. 原始类防止这种情况的唯一方法是声明其方法final。但现在，这通过封装泄漏了实现信息，因为派生类现在无法创建方法hasCredentials - 它会与基类中定义的方法发生冲突.

   这很糟糕：假设这个方法最初在 Base 中不存在。现在，实现者可以合法地派生类 Derived 并为其提供一个按预期工作的方法 hasCredentials。

   但是现在，原始 Base 类的新版本已发布。它的公共接口不会改变（它的不变量也不会改变），所以我们必须期望它不会破坏现有的代码。只有这样，因为现在与派生类中的方法存在名称冲突。

我认为这个问题源于一个误解：

不允许父类的私有方法被“覆盖”（即，在子类中使用相同的签名独立实现），这/不/违反封装性吗？

括号内的文本是相反的 /em> 之前的文本。 Java确实允许您“在子类中使用相同的签名独立实现[私有方法]”。正如我上面所解释的，不允许这样做会违反封装性。

但是“不允许父级的私有方法被“重写””是不同的，并且是确保封装所必需的。

Answer 3

“其他语言（C++ 或 C#）对此有不同的规则吗？”

嗯，C++ 有不同的规则：静态或动态成员函数绑定过程和访问权限强制执行是正交的。

为成员函数赋予private访问权限修饰符意味着该函数只能由其声明类调用，而不能由其他类（甚至派生类）调用。当您将 private 成员函数声明为 virtual 时，甚至是纯虚函数 (virtual void foo() = 0;)，您允许基类从专业化中受益，同时仍然强制执行访问权限。

当涉及到virtual成员函数时，访问权限告诉您应该做什么：

• private virtual意味着您可以专门化该行为，但不能对成员进行调用函数是由基类创建的，当然以受控的方式
• protected virtual 意味着您在重写它时应该/必须调用成员函数的上层类版本

因此，在 C++ 中，访问权限和虚拟性是彼此独立。确定函数是静态绑定还是动态绑定是解决函数调用的最后一步。

最后，模板方法设计模式应该优先于public virtual成员函数。

参考：对话：虚拟您的

本文给出了私有虚拟的实际使用成员函数。

---

ISO/IEC 14882-2003 §3.4.1

如果名称查找发现名称是函数名称，则名称查找可能会将多个声明与名称相关联；据说这些声明形成了一组重载函数（13.1）。重载解析 (13.3) 在名称查找成功后发生。仅当名称查找和函数重载解析（如果适用）成功时，才会考虑访问规则（第 11 条）。只有在名称查找、函数重载解析（如果适用）和访问检查成功之后，名称声明引入的属性才会在表达式处理中进一步使用（第 5 条）。

ISO/IEC 14882-2003 §5.2.2

在成员函数调用中调用的函数通常是根据对象表达式的静态类型（第 10 条）来选择的，但是如果该函数是虚拟的并且没有使用 aqualified-id 指定，那么实际调用的函数将是最终的重写器（ 10.3) 对象表达式的动态类型中的所选函数[注：动态类型是对象表达式的当前值所指向或引用的对象的类型。

Answer 4

子类不能访问或继承父类的私有方法，这符合封装原则。它是隐藏的。

那么，为什么子类应该是
限制实施自己的
具有相同名称/签名的方法？

没有这样的限制。你可以毫无问题地做到这一点，只是不称为“覆盖”。

重写的方法受动态调度的影响，即实际调用的方法是在运行时根据调用的对象的实际类型来选择的。使用私有方法，这种情况不会发生（根据您的第一个声明，也不应该发生）。这就是“私有方法不能被重写”这句话的含义。

Answer 5

我认为您误解了该帖子的内容。这并不是说子类“被限制使用相同的名称/签名实现自己的方法”。

这是稍微编辑过的代码：

public class PrivateOverride {
  private static Test monitor = new Test();

  private void f() {
    System.out.println("private f()");
  }

  public static void main(String[] args) {
    PrivateOverride po = new Derived();
    po.f();
    });
  }
}

class Derived extends PrivateOverride {
  public void f() {
    System.out.println("public f()");
  }
}

以及引用：

您可能合理地期望输出为“public f( )”，

引用该引号的原因是变量 po 实际上保存了 Derived 的实例。但是，由于该方法被定义为私有，因此编译器实际上会查看变量的类型，而不是对象的类型。它将方法调用转换为invokespecial（我认为这是正确的操作码，尚未检查JVM规范）而不是invokeinstance。

Answer 6

这似乎是一个选择和定义的问题。在java中不能这样做的原因是因为规范是这么说的，但问题更多的是规范为什么这么说。

事实上，C++ 允许这样做（即使我们使用 virtual 关键字强制动态分派），这表明没有固有的原因不能允许这样做。

然而，替换该方法似乎完全合法：

class B {
    private int foo() 
    {
        return 42;
    }

    public int bar()
    {
        return foo();
    }
}

class D extends B {
    private int foo()
    {
        return 43;
    }

    public int frob()
    {
        return foo();
    }
}

似乎编译正常（在我的编译器上），但 D.foo 与 B.foo 无关（即它不会覆盖它） - bar() 始终返回 42（通过调用 B.foo），而 frob() 始终返回 43（通过调用 D.foo），无论是在 B 还是 D 实例上调用。

Java 不允许重写该方法的原因之一是他们不喜欢允许更改该方法，如 Konrad Rudolph 的示例中所示。请注意，C++ 在这里有所不同，因为您需要使用“virtual”关键字才能获得动态分派 - 默认情况下它没有，因此您无法修改依赖于 hasCredentials 方法的基类中的代码。上面的示例也可以防止这种情况，因为 D.foo 不会替换 B 中对 foo 的调用。

Answer 7

当该方法是私有的时，它对其子级不可见。所以没有重写它的意义。

Answer 8

对于错误地使用术语“覆盖”并且与我的描述不一致，我深表歉意。我的描述描述了这个场景。以下代码扩展了 Jon Skeet 的示例来描述我的场景：

class Base {
   public void callFoo() {
     foo();
   }
   private void foo() {
   }
}

class Child extends Base {
    private void foo() {
    }
}

用法如下：

Child c = new Child();
c.callFoo();

我遇到的问题是，即使如代码所示，我在子级上调用 callFoo() 方法，也会调用父级 foo() 方法实例变量。我以为我在 Child() 中定义了一个新的私有方法 foo() ，继承的 callFoo() 方法将调用该方法，但我认为 kdgregory 所说的一些内容可能适用于我的场景 - 可能是由于派生类构造函数的方式正在调用 super()，或者可能没有。

Eclipse 中没有编译器警告，并且代码确实可以编译。结果出乎意料。

Answer 9

除了之前所说的之外，不允许重写私有方法还有一个非常语义的原因......它们是私有的！

如果我编写一个类，并指出一个方法是“私有”的，那么外界应该完全看不到它。任何人都不应该能够访问它、覆盖它或进行其他任何操作。我只是应该能够知道这是我独有的方法，没有其他人会破坏它或依赖它。如果有人可以破坏它，它就不能被认为是私人的。我相信事情就是这么简单。

Answer 10

类是通过它提供的方法及其行为方式来定义的。不是那些内部实现方式（例如通过调用私有方法）。

因为封装与行为有关，而不是实现细节，所以私有方法与思想封装无关。从某种意义上来说，你的问题没有任何意义。这就像问“在咖啡中加入奶油如何不违反封装？”

据推测，私有方法是由公共方法使用的。你可以覆盖它。通过这样做，你改变了行为。