Why Java allows increasing the visibility of protected methods in child class?

by

Why decreasing visibility is not allowed is already explained in other responses (it would break the contract of the parent class).

But why it is allowed to increase the visibility of a method? First, it would not break any contract, so there is no reason to not allow it. It can be handy sometimes, when it makes sense in the child class for a method to not be protected.

Second, not allowing it could have the side effect of making impossible sometimes to extend a class and implement an interface at the same time:

interface Interface1 {
   public void method();
}

public class Parent {
   protected abstract void method();
}

public class Child extends Parent implements Interface1 {
   @Override
   public void method() {
   }
   //This would be impossible if the visibility of method() in class Parent could not be increased.
}

About your second question, you can do nothing about it. You have to trust that the person who implements the child class doesn’t do anything that breaks your implementation. Even if java wouldn’t allow to increase visibility, that would still not fix your problem, because a public method with a different name could be created that calls the abstract method:

class Child extends Base{
      @Override
      protected void a(){

      }

      public void a2() {
           a(); //This would have the same problems that allowing to increase the visibility.
      }
}

More Related Contents:

  1. Design Patterns web based applications [closed]
  2. Singletons vs. Application Context in Android?
  3. Why is volatile used in double checked locking
  4. What are static factory methods?
  5. Real World Example of the Strategy Pattern
  6. Design Patterns: Factory vs Factory method vs Abstract Factory
  7. What is the solution for the N+1 issue in JPA and Hibernate?
  8. Long list of if statements in Java
  9. Double Checked Locking in Singleton
  10. Use Cases and Examples of GoF Decorator Pattern for IO
  11. Spring AOP vs AspectJ
  12. Builder Pattern in Effective Java
  13. Is there a Java equivalent or methodology for the typedef keyword in C++?
  14. How to avoid ‘instanceof’ when implementing factory design pattern?
  15. Why implementing a Singleton pattern in Java code is (sometimes) considered an anti-pattern in Java world?
  16. Java JSON serialization – best practice
  17. Visitor pattern’s purpose with examples [duplicate]
  18. Is it bad practice to make a setter return “this”?
  19. Other Ways of Singleton in Java [duplicate]
  20. Open Session In View Pattern
  21. Builder Pattern and Inheritance
  22. Is there a recommended way to use the Observer pattern in MVP using GWT?
  23. In simplest terms, what is a factory?
  24. Why does every object in Java implicitly extend java.lang.Object class?
  25. How to change method behaviour through reflection?
  26. Is This Use of the “instanceof” Operator Considered Bad Design?
  27. Why people use message/event buses in their code? [closed]
  28. Singleton pattern (Bill Pugh’s solution)
  29. How to improve the builder pattern?
  30. Does the Bridge Pattern decouples an abstraction from implementation?

Leave a Comment