在Java中怎么做？在C ++中，什么改变了重写的方法可见性？

Question

In C++ it's possible to change an overridden method's visibility. I find this feature very useful sometimes, for example:

consider you want a class to have some debugging methods, but you don't want them to be visible as public class interface. You could have something like:

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
 }

};

To do so, when using an object of class MyProductionClass, all I can access is MyProductionClass::myClassMethod() (the production interface).

However, if I want to use it's debugging features, I can do this:

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

iface->debug("Hello World");

I've found in my experience this "feature" quite useful. In java this is not possible as it's forbidden to change the visibility of an inherited method. Is there another way I can achieve the above artifact?

Thanks a lot

Answer 1

Personally, I hate when people change method visibility this way. I think it's much better to preserver the visibility and expose interfaces, but not the classes themselves, for external users. Like:

class MyInterface {...}
class MyDebugable {...}

class MyClass : MyInterface, MyDebugable {...}

Give MyInterface to the users and user MyClass internally.

By changing visibility you violate Liskov substitution principle . At the same time your users still can cast to IDebuggable and call your 'private' methods

Answer 2

You cannot reduce visibility of inherited method. This is right. However you can create as many interfaces as you want and make you class to implement these interfaces. Then if your client works with specific interface it "does not have access" to other even public methods.

Here is an example.

public interface Foo {
    public void foo();
} 

public interface Bar {
    public void bar();
} 

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

Here is how we use this class:

Foo f = new MyClass();

You can call foo() here and cannot call bsar() . You can however cast Foo to Bar and then use bar() method.

Answer 3

In Java you can increase method visibility but you can't reduce it when subclassing. This is due to the fact that you may access object via parent class (interface) and all methods defined in parent class should be available to caller.

So the following is possible:

class A {
    protected void foo() {}
}

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

Answer 4

This is (for God's sake) not possible in Java. Furthermore, what you want could be much better achieved by using a logging framework with different configurations for development/production.

Answer 5

Implement a feature discovery like this:

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();