对于初学者来说，考虑这个例子可能会有所帮助；

考虑到我在foo包中开发了MyClass，它有一个很棒的方法，名为print，您有兴趣调用它（它可能是一个方法或属性）

package foo;  // I am in foo 
public class MyClass {
     private void print() { //This is private
        System.out.println("I can print!");
    }
}

您已经开发了YourClass的bar包，您有兴趣使用MyClass#print

package bar; \\You are not in same package as me 
import foo.MyClass;    
public class YourClass {
    void test() {
        MyClass myClass = new MyClass();
        myClass.print();
    }
}

您的代码未编译，并且出现错误。方法print（）对于类型MyClass未定义

你来找我：

你：我想用你的方法，但它是私人的。你能公开吗？我：不，我不想让别人使用你：我是你的朋友，至少让我不要让别人使用它。我：好的，我将删除私有关键字。我的访问修饰符将是默认的或私有的包。因为你们是我的朋友，你们必须和我在同一个包裹里。所以你们必须来到我的包裹里。我的意思是确切的包，甚至不是子包。

然后MyClass将

package foo;    
public class MyClass {    
    void print() { //No access modifier means default or package-private 
        System.out.println("I can print!");
    }   
}

YourClass将是：

package foo;//You come to my package
public class YourClass {
    void test() {
        MyClass myClass = new MyClass();
        myClass.print();
    }
}

不考虑这个：你又来找我了

你：我的老板告诉我我不能改变我的包（在实际世界中，你不能改变你的包以使用其他类方法）我：还有另一种方法，如果你扩展我，我使print（）受到保护，那么无论你是否更改包，你都可以使用它。（因此，子类将始终允许您访问我的方法）。

这是我的班级

package foo;
protected class MyClass { // it is now protected
     protected void print() {
        System.out.println("I can print!");
    }   
}

这是YourClass

package bar; // You are on your own package
import foo.MyClass;
public class YourClass extends MyClass {
    void  test() {
        //You initiate yourself! But as you extend me you can call my print()
        YourClass yourClass = new YourClass(); 
        yourClass.print();
    }
}

您可能已经注意到，通过使一个方法受到保护，所有其他类都可以通过扩展它来使用它，您无法轻松控制如何使用它。这在java17中通过引入密封和许可词来解决。因此，您可以定义哪些类可以扩展您。类似于公共密封类MyClass允许YourClass参见Java17中的密封类是什么？有关详细信息

官方教程可能对您有所帮助。

+：可访问空白：不可访问

Java中最容易被误解的访问修饰符是受保护的。我们知道它类似于默认修饰符，只有一个例外，子类可以看到它？这里有一个例子，希望能澄清这一困惑：

假设我们有2个类；父亲和儿子，每个人都有自己的包装：包父包；公共课父亲{}-------------------------------------------package-sonpackage；公共课儿子延伸父亲{}让我们向Father添加一个受保护的方法foo（）。包父包；公共课父亲{受保护的void foo（）｛｝}方法foo（）可以在4种上下文中调用：在位于定义foo（）的同一包中的类内（父包）：包父包；公共类SomeClass{公共无效方法（父f，子s）{f.foo（）；s.foo（）；}}在子类内部，在当前实例上通过this或super：package-sonpackage；公共课儿子延伸父亲{public void sonMethod（）{this.foo（）；super.foo（）；}}在类型为同一类的引用上：包父包；公共课父亲{公共无效父方法（父f）{f.foo（）；//即使foo（）是私有的，也有效}}-------------------------------------------package-sonpackage；公共课儿子延伸父亲{公共无效sonMethod（Sons）{s.foo（）；}}在一个类型为父类的引用上，该引用位于定义foo（）的包内（父包）[这可以包含在上下文1中]：包父包；公共课儿子延伸父亲{公共无效sonMethod（父f）{f.foo（）；}}以下情况无效。在类型为父类且位于定义foo（）的包（父包）外部的引用上：package-sonpackage；公共课儿子延伸父亲{公共无效sonMethod（父f）{f.foo（）；//编译错误}}子类包中的非子类（子类从其父类继承受保护的成员，并使其成为非子类的私有成员）：package-sonpackage；公共类SomeClass{public void someMethod（儿子）引发异常{s.foo（）；//编译错误}}

（注意：我不是一个Java程序员，我是一个Perl程序员。Perl没有正式的保护措施，这也许就是为什么我如此理解这个问题的原因：）

私有的

就像你想的那样，只有声明它的类才能看到它。

包专用

它只能由声明它的包看到和使用。这是Java中的默认设置（有些人认为这是错误的）。

受保护的

包Private+可以由子类或包成员看到。

平民的

每个人都能看到。

出版

在我控制的代码之外可见。（虽然不是Java语法，但这对本次讨论很重要）。

C++定义了一个称为“朋友”的附加级别，你对它了解得越少越好。

你什么时候应该用什么？整个想法是封装以隐藏信息。您希望尽可能地向用户隐藏某些操作的细节。为什么？因为这样你以后就可以更改它们，而不会破坏任何人的代码。这使您可以优化、重构、重新设计和修复错误，而不用担心有人在使用您刚刚大修过的代码。

因此，经验法则是让事物尽可能地可见。从私密开始，只在需要时增加更多的可见性。只公开用户需要知道的信息，你公开的每一个细节都限制了你重新设计系统的能力。

如果您希望用户能够自定义行为，而不是将内部公开以便他们可以覆盖它们，那么通常最好将这些内容插入到对象中并将接口公开。这样他们就可以简单地插入一个新对象。例如，如果您正在编写一个CD播放器，并希望“go find info about this CD”位可定制，而不是将这些方法公开，那么您应该将所有这些功能放入其对象中，并仅将对象getter/setter公开。通过这种方式，吝啬于暴露自己的内心会鼓励良好的组合和关注的分离

我只坚持“私人”和“公共”。许多OO语言都有这一点。“受保护”可能很方便，但这是一个骗局。一旦一个接口超过了私有，它就超出了你的控制范围，你必须去查看其他人的代码才能找到用途。

这就是“发布”的概念所在。更改接口（重构它）需要找到使用它的所有代码并进行更改。如果接口是私有的，那么没问题。如果它受到保护，你必须找到所有的子类。如果它是公开的，你必须找到使用你的代码的所有代码。有时这是可能的，例如，如果您正在编写仅供内部使用的公司代码，那么接口是否公开无关紧要。您可以从公司存储库中获取所有代码。但是，如果一个接口被“发布”，如果有代码在您的控制之外使用它，那么您将被罚款。您必须支持该接口，否则可能会破坏代码。即使是受保护的接口也可以被认为是已发布的（这就是为什么我不关心受保护的）。

许多语言发现公共/受保护/私有的等级性质过于局限，不符合现实。为此，有一种特质类的概念，但这是另一种表现。

私人：仅限上课

默认值（无修饰符）：对类和包的访问受限

受保护：对类、包和子类的访问受限（包内部和外部）

公共：可访问类、包（所有）和子类。。。简而言之，无处不在。

对于初学者来说，考虑这个例子可能会有所帮助；

考虑到我在foo包中开发了MyClass，它有一个很棒的方法，名为print，您有兴趣调用它（它可能是一个方法或属性）

package foo;  // I am in foo 
public class MyClass {
     private void print() { //This is private
        System.out.println("I can print!");
    }
}

您已经开发了YourClass的bar包，您有兴趣使用MyClass#print

package bar; \\You are not in same package as me 
import foo.MyClass;    
public class YourClass {
    void test() {
        MyClass myClass = new MyClass();
        myClass.print();
    }
}

您的代码未编译，并且出现错误。方法print（）对于类型MyClass未定义

你来找我：

你：我想用你的方法，但它是私人的。你能公开吗？我：不，我不想让别人使用你：我是你的朋友，至少让我不要让别人使用它。我：好的，我将删除私有关键字。我的访问修饰符将是默认的或私有的包。因为你们是我的朋友，你们必须和我在同一个包裹里。所以你们必须来到我的包裹里。我的意思是确切的包，甚至不是子包。

然后MyClass将

package foo;    
public class MyClass {    
    void print() { //No access modifier means default or package-private 
        System.out.println("I can print!");
    }   
}

YourClass将是：

package foo;//You come to my package
public class YourClass {
    void test() {
        MyClass myClass = new MyClass();
        myClass.print();
    }
}

不考虑这个：你又来找我了

你：我的老板告诉我我不能改变我的包（在实际世界中，你不能改变你的包以使用其他类方法）我：还有另一种方法，如果你扩展我，我使print（）受到保护，那么无论你是否更改包，你都可以使用它。（因此，子类将始终允许您访问我的方法）。

这是我的班级

package foo;
protected class MyClass { // it is now protected
     protected void print() {
        System.out.println("I can print!");
    }   
}

这是YourClass

package bar; // You are on your own package
import foo.MyClass;
public class YourClass extends MyClass {
    void  test() {
        //You initiate yourself! But as you extend me you can call my print()
        YourClass yourClass = new YourClass(); 
        yourClass.print();
    }
}

您可能已经注意到，通过使一个方法受到保护，所有其他类都可以通过扩展它来使用它，您无法轻松控制如何使用它。这在java17中通过引入密封和许可词来解决。因此，您可以定义哪些类可以扩展您。类似于公共密封类MyClass允许YourClass参见Java17中的密封类是什么？有关详细信息