Change the access modifier of an overridden method

Question

Is there a reason one can change the access modifier of an overridden method? For instance,

abstract class Foo{
    void start(){...}
}

And then change the package-private access modifier to public,

final class Bar extends Foo{
    @Override
    public void start(){...}
}

I'm just asking this question out of curiosity.

Answer 1

The explaination is this:-

It's a fundamental principle in OOP: the child class is a fully-fledged instance of the >parent class, and must therefore present at least the same interface as the parent class. >Making protected/public things less visible would violate this idea; you could make child >classes unusable as instances of the parent class.

 class Person{
 public void display(){
  //some operation
 }
 }

class Employee extends Person{
private void display(){
   //some operation
 }


 Person p=new Employee();

Here p is the object reference with type Person(super class),when we are calling >p.display() as the access modifier is more restrictive the object reference p cannot access child object of type Employee

Answer 2

Extending a class means the subclass should at least offer the same functionality to the other classes.

If he extends that, then it is not a problem.

Extending could be be either adding new methods or by offering existing methods to more classes like making a package-access method public.

Answer 3

There is only one, you might want the override to be visible by more classes, since no modifier is default, public broadens that.

Answer 4

Edit: OK, I changed my answer to fix the problem.

If that couldn't be done, then there would be some cases where a class wouldn't be able to implement an iterface and extend a class because they have the same method with different access modifiers.

public Interface A {
  public void method();
}

public abstract classs B {
  protected void method();
}

public class AB extends B implements A {
  /*
   * This would't be possible if the access modifier coulnd't be changed
   * to less restrictive
  */
  public void method();
}

Answer 5

Java doesn't let you make the access modifier more restrictive, because that would violate the rule that a subclass instance should be useable in place of a superclass instance. But when it comes to making the access less restrictive... well, perhaps the superclass was written by a different person, and they didn't anticipate the way you want to use their class.

The programs people write and the situations which arise when programming are so varied, that it's better for language designers not to "second-guess" what programmers might want to do with their language. If there is no good reason why a programmer should not be able to make access specifiers less restrictive in a subclass (for example), then it's better to leave that decision to the programmer. They know the specifics of their individual situation, but the language designer does not. So I think this was a good call by the designers of Java.