Java 中的接口：无法将实现的方法设置为受保护或私有

Question

我知道接口必须是公共的。 然而，我不想要这样。

我希望我实现的方法只能从它们自己的包中访问，所以我希望我实现的方法受到保护。

问题是我无法保护接口或实现的方法。

什么是解决办法？ 有没有与这个问题相关的设计模式？

根据 Java 指南，抽象类也无法完成这项工作。

Answer 1

阅读此。

“公共访问说明符表明该接口可以被任何包中的任何类使用。如果您没有指定该接口是公共的，则您的接口将只能被与该接口在同一包中定义的类访问< /强>。”

那是你要的吗？

Answer 2

您的类可以使用包保护并仍然实现一个接口：

class Foo implements Runnable 
{
    public void run()
    {
    }
}

如果您希望某些方法受到保护/包而其他方法则不受到保护/包，那么听起来您的类有多个职责，并且应该分为多个。

阅读对此回复和其他回复的评论后进行编辑：

如果您以某种方式认为方法的可见性会影响调用该方法的能力，请再考虑一下。 如果不走极端，您就无法阻止某人使用反射来识别您的类的方法并调用它们。 然而，这不是问题：除非有人试图破解您的代码，否则他们不会调用随机方法。

相反，将私有/受保护方法视为定义子类的契约，并使用接口来定义与外界的契约。

哦，对于决定我的示例应该使用 K&R 支撑的人：如果服务条款中指定，当然可以。 否则，你就不能找到更好的事情来打发你的时间吗？

Answer 3

当我遇到这个问题时，我使用包可访问的内部或嵌套类来实现接口，将实现的方法从公共类中推出。

通常是因为我有一个具有特定公共 API 的类，它必须实现其他东西才能完成它的工作（通常是因为其他东西是伪装成接口的回调） - 这种情况在 Comparable 之类的事情上经常发生。 我不希望公共 API 被（强制公共）接口实现所污染。

希望这可以帮助。

另外，如果您确实想要仅由包访问的方法，则不需要 protected 范围说明符，您需要默认（省略）范围说明符。 当然，使用 protected 将允许子类看到这些方法。

顺便说一句，我认为接口方法被推断为公共的原因是因为拥有一个仅由同一包中的类实现的接口是非常例外的； 它们最常被另一个包中的某些东西调用，这意味着它们需要公开。

Answer 4

这个问题是基于一个错误的陈述：

我知道接口必须是公共的

事实并非如此，您可以拥有带有默认访问修饰符的接口。

问题是我无法使接口或实现的方法受到保护

这里是：

C:\oreyes\cosas\java\interfaces>type a\*.java
a\Inter.java
package a;

interface Inter {
    public void face();
}

a\Face.java
package a;

class Face implements Inter {
    public void face() {
        System.out.println( "face" );
    }
}


C:\oreyes\cosas\java\interfaces>type b\*.java
b\Test.java

package b;
import a.Inter;
import a.Face;

public class Test {
    public static void main( String [] args ) {
        Inter inter = new Face();
        inter.face();
    }
}

C:\oreyes\cosas\java\interfaces>javac -d . a\*.java b\Test.java
b\Test.java:2: a.Inter is not public in a; cannot be accessed from outside package
import a.Inter;
        ^
b\Test.java:3: a.Face is not public in a; cannot be accessed from outside package
import a.Face;
        ^
b\Test.java:7: cannot find symbol
symbol  : class Inter
location: class b.Test
        Inter inter = new Face();
        ^
b\Test.java:7: cannot find symbol
symbol  : class Face
location: class b.Test
        Inter inter = new Face();
                          ^
4 errors

C:\oreyes\cosas\java\interfaces>

因此，实现你想要的，防止在包之外使用接口和类。

Answer 5

以下是如何使用抽象类来完成此操作。

唯一不方便的是它使你成为“子类”。

根据 java 指南，您应该“大多数”时候遵循该建议，但我认为在这种情况下就可以了。

public abstract class Ab { 
    protected abstract void method();
    abstract void otherMethod();
    public static void main( String [] args ) { 
        Ab a = new AbImpl();
        a.method();
        a.otherMethod();
    }
}
class AbImpl extends Ab {
    protected void method(){
        System.out.println( "method invoked from: " + this.getClass().getName() );
    }
    void otherMethod(){ 
        System.out.println("This time \"default\" access from: " + this.getClass().getName()  );
    }
}

Answer 6

这是另一个解决方案，其灵感来自于 C++ Pimpl 习惯用法。

如果您想要实现一个接口，但不希望该实现是公共的，则可以创建一个实现该接口的匿名内部类的组合对象。

这是一个例子。 假设您有这个接口：

public interface Iface {
    public void doSomething();
}

您创建一个 Iface 类型的对象，并将实现放入其中：

public class IfaceUser {
    private int someValue;
    // Here's our implementor
    private Iface impl = new Iface() {
        public void doSomething() {
            someValue++;
        }
    };
}

每当您需要调用 doSomething() 时，您就可以在您的组合 impl 对象。

Answer 7

我刚刚遇到这个问题，试图构建一个受保护的方法，其目的是仅在测试用例中使用它。 我想删除填充到数据库表中的测试数据。 无论如何，我的灵感来自 @Karl Giesing 的 帖子。 不幸的是它没有起作用。 我确实找到了一种使用受保护的内部类使其工作的方法。

接口：

package foo;
interface SomeProtectedFoo {
    int doSomeFoo();
}

然后在公共类中定义为受保护的内部类：

package foo;
public class MyFoo implements SomePublicFoo {
    // public stuff
    protected class ProtectedFoo implements SomeProtectedFoo {
        public int doSomeFoo() { ... }
    }
    protected ProtectedFoo pFoo;
    protected ProtectedFoo gimmeFoo() {
        return new ProtectedFoo();
    }
}

然后您只能从同一包中的其他类访问受保护的方法，正如我的测试代码所示：

package foo;
public class FooTest {
    MyFoo myFoo = new MyFoo();
    void doProtectedFoo() {
        myFoo.pFoo = myFoo.gimmeFoo();
        myFoo.pFoo.doSomeFoo();
    }
}

对于原始海报来说有点晚了，但是嘿，我刚刚找到了。 ：D

Answer 8

您可以使用封装而不是继承。

也就是说，创建您的类（不会继承任何内容）并在其中包含您要扩展的对象的实例。

然后你就可以只公开你想要的内容。

这样做的明显缺点是您必须显式传递您想要公开的所有内容的方法。 而且它不会是一个子类......

Answer 9

我只想创建一个抽象类。 这没有什么坏处。

Answer 10

对于接口，您希望定义可以由各种实现类公开的方法。
拥有一个带有受保护方法的接口并不能达到这个目的。

我猜你的问题可以通过重新设计你的类层次结构来解决。

Answer 11

解决这个问题的一种方法是（根据情况）创建一个匿名内部类来实现具有受保护或私有范围的接口。 例如：

public class Foo {
    interface Callback {
        void hiddenMethod();
    }

    public Foo(Callback callback) {
    }
}

然后在 Foo 的用户中：

public class Bar {
    private Foo.Callback callback = new Foo.Callback() { 
        @Override public void hiddenMethod() { ... }
    };
    private Foo foo = new Foo(callback);
}

这可以让您避免出现以下情况：

public class Bar implements Foo.Callback {
    private Foo foo = new Foo(this);

    // uh-oh! the method is public!
    @Override public void hiddenMethod() { ... }
}

Answer 12

我想你现在可以在 Java 9 版本中使用它。 来自 Java 9 的 openJDK 注释，

简要考虑了对接口中私有方法的支持
作为添加支持的一部分，包含在 Java SE 8 中
Lambda 表达式，但被撤回以更好地关注更高的
Java SE 8 的优先任务。现在建议支持
采取私有接口方法，从而实现非抽象
接口的方法以在它们之间共享代码。

参考 https://bugs.openjdk.java.net/browse/JDK-8071453