在java.lang.Object类中拥有受保护方法的目的是什么？

Question

When every class in Java derives from java.lang.Object then what is the purpose of having protected methods in the Object class? They will always have the same visibility as public methods.Is there any reason why the following two methods are protected in the OpenJDK implementation?

    protected native Object clone() throws CloneNotSupportedException;

    protected void finalize() throws Throwable { }

Edit: The comment stating new Object.finalize() is the best answer I could have anticipated! ..Thanks

For those who are differentiating accessibility of protected and public

  package pkg1;
   public class Parent{
    protected void fun(){}
     }

package pkg2;
public class child extends pkg1.Parent{
  void fun2()
   {  child ch=new child();
      ch.fun();   // Accesses protected method (For this class protected /public is irrelevant in terms of accessibility
      Parent p=new Parent();
      //p.fun(); //can't do this
   }
  }

Answer 1

Controlling "visibility" of elements in class is important. (See language tutorial here )

As a quick summary, consider:

1. private things are only visible to the class they are in
2. no modifier/default are only visible to the class and the package the class is in
3. protected things are visible to packages , class AND to sub-classes
4. public things are visible to package , class , sub-classes AND the world

Answer 2

Yes it makes sanse as they will be visible for extending classes and in the same package but nowhere else. If aB extends Object and bC extends Object than aB cannot call bC#clone() method.

The same is with finalize. You can override it as it is protected, but you cannot call it from any possible context.

Answer 3

protected methods / variables / .. are usually intended to be useful from subclasses only.

protected is also visible within the same package but that's typically not the intention since that case is already covered when leaving visibility at default (ie not defining one of private , protected or public ).

So the typical intention of a protected method is either that subclasses can override that method to specialize the behavior or that they are being allowed to call that method (but outside classes are not - goal: encapsulation)

For example Object#finalize() does nothing per default but subclasses can (usually should not) do special cleanup operations in there when an object is garbage collected.