如何在java中做什么在C++；是否正在更改重写的方法可见性？ 在C++中，可以改变重写方法的可见性。我发现这个功能有时非常有用，例如：

假设您希望类具有一些调试方法，但不希望它们作为公共类接口可见。你可以有这样的东西：

class IDebuggable {
public:
 virtual void debug(std::string s) = 0;
};

class MyProductionClass: public IDebuggable

public:
 void myClassMethod() {}

private:
 virtual void debug(std::string) {
  // do some debug here
 }

};

为此，当使用MyProductionClass类的对象时，我只能访问MyProductionClass:：myClassMethod（）（生产接口）

但是，如果我想使用它的调试功能，我可以这样做：

MyProductionClass* obj = new MyProductionClass();
IDebuggable* iface = obj;

iface->debug("Hello World");

根据我的经验，我发现这个“功能”非常有用。 在java中，这是不可能的，因为禁止更改继承方法的可见性。 有没有其他方法可以实现上述工件

---

非常感谢

就我个人而言，我讨厌人们以这种方式改变方法可见性。我认为为外部用户保留可见性和公开接口（而不是类本身）要好得多。 比如：

将

MyInterface

提供给用户和用户

MyClass

内部

---

更改可见性违反了

Liskov替换原则

。同时，您的用户仍然可以强制转换到

IDebuggable

并亲自调用您的“私有”方法，我讨厌人们以这种方式更改方法可见性。我认为为外部用户保留可见性和公开接口（而不是类本身）要好得多。 比如：

将

MyInterface

提供给用户和用户

MyClass

内部

更改可见性违反了

Liskov替换原则

。同时，您的用户仍然可以强制转换到

IDebuggable

并调用您的“私有”方法

这在Java中是不可能的（看在上帝的份上）。此外，通过为开发/生产使用具有不同配置的日志框架，可以更好地实现您想要的功能。

这在Java中是不可能的（看在上帝的份上）。此外，通过使用具有不同开发/生产配置的日志框架，可以更好地实现您想要的功能。

您不能降低继承方法的可见性。这是对的。但是，您可以创建任意数量的接口，并使用类来实现这些接口。然后，如果您的客户机使用特定的接口，它“无权访问”其他甚至是公共的方法

这里有一个例子

public interface Foo {
    public void foo();
} 

public interface Bar {
    public void bar();
} 

public class MyClass implements Foo, Bar {
    public void foo() {}
    public void bar() {}
}

下面是我们如何使用该类：

Foo f=new MyClass（）

您可以在此处调用
foo（）
，但不能调用
bsar（）
。但是，您可以将
Foo
强制转换为
Bar
，然后使用
Bar（）
方法。
您不能降低继承方法的可见性。这是对的。但是，您可以创建任意数量的接口，并使用类来实现这些接口。然后，如果您的客户机使用特定的接口，它“无权访问”其他甚至是公共的方法

这里有一个例子

public interface Foo {
    public void foo();
} 

public interface Bar {
    public void bar();
} 

public class MyClass implements Foo, Bar {
    public void foo() {}
    public void bar() {}
}

下面是我们如何使用该类：

Foo f=new MyClass（）

您可以在此处调用
foo（）
，但不能调用
bsar（）
。但是，您可以将
Foo
转换为
Bar
，然后使用
Bar（）
方法。
在Java中，您可以增加方法的可见性，但在子类化时不能减少它。这是因为您可以通过父类（接口）访问对象，并且父类中定义的所有方法都应该对调用方可用

因此，以下是可能的：

class A {
    protected void foo() {}
}

class B extends A {
    @Override
    public void foo() {}
}

在Java中，可以提高方法的可见性，但在子类化时不能降低可见性。这是因为您可以通过父类（接口）访问对象，并且父类中定义的所有方法都应该对调用方可用

因此，以下是可能的：

class A {
    protected void foo() {}
}

class B extends A {
    @Override
    public void foo() {}
}

实现如下功能发现：

class A {

    public final T <T> lookup(Class<T> klazz) {
        return map.get(klazz);
    }

    public A() {
        map.put(IDebugable.class, new IDebuggable() { ... };
    }
}

A a = ...;
a.lookup(IDebuggable.class).debug();

A类{
公开最终T查找（klazz类）{
返回地图。获取（klazz）；
}
公共A（）{
put（IDebugable.class，新的IDebugable（）{…}；
}
}
A=。。。；
a、 查找（IDebuggable.class）.debug（）；
实现如下功能发现：

class A {

    public final T <T> lookup(Class<T> klazz) {
        return map.get(klazz);
    }

    public A() {
        map.put(IDebugable.class, new IDebuggable() { ... };
    }
}

A a = ...;
a.lookup(IDebuggable.class).debug();

A类{
公开最终T查找（klazz类）{
返回地图。获取（klazz）；
}
公共A（）{
put（IDebugable.class，新的IDebugable（）{…}；
}
}
A=。。。；
a、 查找（IDebuggable.class）.debug（）；
@TadeuszKopec:我认为它更多的是作为一种替代方式来做事情。因此我认为它确实回答了这个问题。我同意Tadeusz和Tdorno的观点，你没有提供任何答案。@Misalevable:答案是不这样做。并且为用户提供接口，而不是通过链接可见性来隐藏方法。don't want to in一个主观的论点，但我认为Java放弃了LSP，使用了
UnsupportedOperationException
和
Stack implements List
对不起，这是我在这里的第一篇文章，所以我不知道有“传统的代码格式”规则。我会看的。@TadeuszKopec：我认为它更像是做事情的另一种方式。所以我认为它确实回答了这个问题。我同意Tadeusz和Tdorno，你没有提供任何答案。@Misalevable:答案是不这样做。并为用户提供接口，而不是通过链接可见性来隐藏方法我不想陷入主观的争论，但我认为Java放弃了LSP，使用了
UnsupportedOperationException
和
Stack implements List
对不起，这是我在这里的第一篇文章，所以我不知道有“传统的代码格式”规则。我来看看。在发布另一段代码之前，请先学习传统的代码格式。@t请礼貌：）@Misarable我很礼貌。。我说please@Tdorno很抱歉，我发布了格式不好的代码，尽管我必须说读起来并不复杂（而且只有很少几行），所以我觉得没关系。我会付钱的