[英]What is the difference between public, protected, package-private and private in Java?
在 Java 中，在制作class和interface以及处理 inheritance 时，是否有明确规定何时使用每个访问修饰符，即默认（包私有）、 public 、 protected和private ？
官方教程可能对你有用。
| 班级 | 包裹 | 子类 （相同的包装） |
子类 （差异包） |
世界 | |
|---|---|---|---|---|---|
public |
+ | + | + | + | + |
protected |
+ | + | + | + | |
| 没有修饰符 | + | + | + | ||
private |
+ |
+ : 可访问
空白：不可访问
（警告：我不是 Java 程序员，我是 Perl 程序员。Perl 没有正式的保护，这也许是我对问题如此了解的原因:)）
就像您想的那样，只有声明它的类才能看到它。
它只能被声明它的包看到和使用。 这是 Java 中的默认设置（有些人认为这是错误的）。
Package Private + 可以被子类或包成员看到。
每个人都可以看到它。
在我控制的代码之外可见。 （虽然不是 Java 语法，但对于本次讨论很重要）。
C++ 定义了一个名为“朋友”的附加级别，您对此了解得越少越好。
什么时候应该使用什么？ 整个想法是封装以隐藏信息。 您希望尽可能地向用户隐藏某些事情是如何完成的细节。 为什么？ 因为那样你以后就可以更改它们而不会破坏任何人的代码。 这使您可以优化、重构、重新设计和修复错误，而不必担心有人在使用您刚刚大修的代码。
因此，经验法则是使事物仅在必须可见的情况下才可见。 从私有开始，仅根据需要添加更多可见性。 只公开用户绝对需要知道的内容，您公开的每个细节都会限制您重新设计系统的能力。
如果您希望用户能够自定义行为，而不是公开内部结构以便他们可以覆盖它们，那么将这些胆量推入一个对象并使该接口公开通常是一个更好的主意。 这样他们就可以简单地插入一个新对象。 例如，如果您正在编写 CD 播放器并希望“查找有关此 CD 的信息”位可自定义，而不是将这些方法公开，您会将所有这些功能放入其自己的对象中，并仅将您的对象 getter/setter 公开. 通过这种方式，吝啬暴露你的胆量可以鼓励良好的构图和关注点的分离
就个人而言，我坚持只使用“私人”和“公共”。 许多面向对象的语言就是这样。 “受保护”可能很方便，但它确实是个骗局。 一旦接口不再是私有的，它就超出了您的控制范围，您必须查看其他人的代码才能找到用途。
这就是“已发布”的想法出现的地方。更改接口（重构它）需要您找到所有使用它的代码并对其进行更改。 如果接口是私有的，那么没问题。 如果它受到保护，你必须去寻找你所有的子类。 如果它是公开的，您必须去查找所有使用您的代码的代码。 有时这是可能的，例如，如果您正在处理仅供内部使用的公司代码，那么接口是否公开并不重要。 您可以从公司存储库中获取所有代码。 但是如果一个接口被“发布”了，如果有代码在你的控制之外使用它，那么你就被灌输了。 您必须支持该接口或冒破坏代码的风险。 甚至受保护的接口也可以被视为已发布（这就是为什么我不打扰受保护的原因）。
许多语言发现公共/受保护/私有的等级性质过于局限，不符合现实。 为此，有一个trait class的概念，但那是另一个节目。
这是该表的更好版本，其中还包括一列模块。
私有成员 ( i )只能在声明的同一类中访问。
没有访问修饰符( j ) 的成员只能在同一个包中的类中访问。
受保护成员 ( k ) 可在同一包中的所有类以及其他包中的子类中访问。
所有类都可以访问公共成员 ( l )（除非它驻留在不导出声明它的包的模块中）。
访问修饰符是一种帮助您防止意外破坏封装(*) 的工具。 问问自己，您是否希望成员成为类、包、类层次结构的内部成员，或者根本不是内部成员，然后相应地选择访问级别。
例子：
long internalCounter可能应该是私有的，因为它是可变的并且是一个实现细节。void beforeRender()方法应该受到保护。void saveGame(File dst)方法应该是公开的。(*) 究竟什么是封装？
____________________________________________________________________
| highest precedence <---------> lowest precedence
*———————————————+———————————————+———————————+———————————————+———————
\ xCanBeSeenBy | this | any class | this subclass | any
\__________ | class | in same | in another | class
\ | nonsubbed | package | package |
Modifier of x \ | | | |
————————————————*———————————————+———————————+———————————————+———————
public | ✔ | ✔ | ✔ | ✔
————————————————+———————————————+———————————+———————————————+———————
protected | ✔ | ✔ | ✔ | ✘
————————————————+———————————————+———————————+———————————————+———————
package-private | | | |
(no modifier) | ✔ | ✔ | ✘ | ✘
————————————————+———————————————+———————————+———————————————+———————
private | ✔ | ✘ | ✘ | ✘
____________________________________________________________________
简单的规则。 从声明一切私有开始。 然后随着需求的出现和设计的需要，向公众迈进。
在公开成员时，问问自己是公开表示选择还是抽象选择。 第一个是您想要避免的，因为它会引入对实际表示而不是其可观察行为的太多依赖。
作为一般规则，我尽量避免通过子类化来覆盖方法实现； 太容易搞砸逻辑了。 如果您打算覆盖它，请声明抽象受保护的方法。
此外，在重写时使用 @Override 注释以防止重构时破坏。
它实际上比简单的网格显示要复杂一些。 网格告诉您是否允许访问，但究竟什么构成访问？ 此外，访问级别以复杂的方式与嵌套类和继承交互。
“默认”访问（由缺少关键字指定）也称为package-private 。 例外：在接口中，没有修饰符意味着公共访问； 禁止使用 public 以外的修饰符。 枚举常量总是公开的。
是否允许使用此访问说明符访问成员？
private ：仅当成员在与调用代码相同的类中定义时。protected ：相同的包，或者如果在包含调用代码的类的超类中定义了成员。public ：是的。局部变量和形式参数不能采用访问说明符。 由于根据范围规则，它们本质上是不可访问的，因此它们实际上是私有的。
对于顶级范围内的类，只允许使用public和 package-private。 这种设计选择大概是因为protected和private在包级别是多余的（没有包的继承）。
所有访问说明符都可以用于类成员（构造函数、方法和静态成员函数、嵌套类）。
相关： Java 类可访问性
访问说明符可以严格排序
公共 > 受保护 > 包私有 > 私有
这意味着public提供最多的访问权限， private最少。 任何可能对私有成员的引用也对包私有成员有效； 对包私有成员的任何引用在受保护成员上都是有效的，依此类推。 （将受保护成员的访问权限授予同一包中的其他类被认为是错误的。）
private[this]支持它。）您还必须考虑嵌套作用域，例如内部类。 复杂性的一个例子是内部类具有成员，这些成员本身可以使用访问修饰符。 所以你可以有一个带有公共成员的私有内部类； 可以访问会员吗？ （见下文。）一般规则是查看范围并递归思考以查看您是否可以访问每个级别。
但是，这相当复杂，有关详细信息， 请参阅 Java 语言规范。 （是的，过去曾出现过编译器错误。）
要了解这些交互方式，请考虑此示例。 有可能“泄露”私有内部类； 这通常是一个警告：
class Test {
public static void main(final String ... args) {
System.out.println(Example.leakPrivateClass()); // OK
Example.leakPrivateClass().secretMethod(); // error
}
}
class Example {
private static class NestedClass {
public void secretMethod() {
System.out.println("Hello");
}
}
public static NestedClass leakPrivateClass() {
return new NestedClass();
}
}
编译器输出：
Test.java:4: secretMethod() in Example.NestedClass is defined in an inaccessible class or interface
Example.leakPrivateClass().secretMethod(); // error
^
1 error
一些相关问题：
根据经验：
private ：类范围。default （或package-private ）：包范围。protected : package scope + child包（类似于包，但我们可以从不同的包中继承它）。 protected 修饰符始终保持“父子”关系。public ：无处不在。因此，如果我们将访问权限划分为三个权限：
然后我们有这个简单的表格：
+—-———————————————+————————————+———————————+
| | Same | Different |
| | Package | Packages |
+—————————————————+————————————+———————————+
| private | D | |
+—————————————————+————————————+———————————+
| package-private | | |
| (no modifier) | D R I | |
+—————————————————+————————————+———————————+
| protected | D R I | I |
+—————————————————+————————————+———————————+
| public | D R I | R I |
+—————————————————+————————————+———————————+
简而言之
public ：可从任何地方访问。protected ：可以被同一个包的类和驻留在任何包中的子类访问。private ：只能在同一个类中访问。 Java 中最容易被误解的访问修饰符是protected 。 我们知道它类似于默认修饰符，但有一个例外，子类可以看到它。 但是如何？ 这是一个希望澄清混淆的示例：
假设我们有 2 个类； Father和Son ，每个人都有自己的包裹：
package fatherpackage; public class Father { } ------------------------------------------- package sonpackage; public class Son extends Father { } 让我们向Father添加一个受保护的方法foo() 。
package fatherpackage; public class Father { protected void foo(){} } 方法foo()可以在 4 个上下文中调用：
在位于定义foo()的同一个包中的类中 ( fatherpackage )：
package fatherpackage; public class SomeClass { public void someMethod(Father f, Son s) { f.foo(); s.foo(); } } 在子类中，通过this或super在当前实例上：
package sonpackage; public class Son extends Father { public void sonMethod() { this.foo(); super.foo(); } }在类型为同一类的引用上：
package fatherpackage; public class Father { public void fatherMethod(Father f) { f.foo(); // valid even if foo() is private } } ------------------------------------------- package sonpackage; public class Son extends Father { public void sonMethod(Son s) { s.foo(); } } 在类型为父类的引用上，它位于定义foo()的包内( fatherpackage ) [这可以包含在上下文号中。 1]：
package fatherpackage; public class Son extends Father { public void sonMethod(Father f) { f.foo(); } }以下情况无效。
在类型为父类且位于定义foo()的包之外的引用上 ( fatherpackage )：
package sonpackage; public class Son extends Father { public void sonMethod(Father f) { f.foo(); // compilation error } }子类包内的非子类（子类从其父类继承受保护的成员，并使它们对非子类私有）：
package sonpackage; public class SomeClass { public void someMethod(Son s) throws Exception { s.foo(); // compilation error } }声明为私有的方法、变量和构造函数只能在声明的类本身内访问。
私有访问修饰符是最严格的访问级别。 类和接口不能是私有的。
笔记
如果类中存在公共 getter 方法，则可以在类外访问声明为私有的变量。 在超类中声明为 protected 的变量、方法和构造函数只能被其他包中的子类或受保护成员类的包内的任何类访问。
protected 访问修饰符不能应用于类和接口。
方法、字段可以声明为protected，但是接口中的方法和字段不能声明为protected。
笔记
受保护的访问使子类有机会使用辅助方法或变量，同时防止不相关的类尝试使用它。
可以从任何其他类访问声明为 public 的类、方法、构造函数、接口等。
因此，可以从属于 Java Universe 的任何类访问公共类中声明的字段、方法、块。
但是，如果我们尝试访问的公共类在不同的包中，那么仍然需要导入公共类。
由于类继承，类的所有公共方法和变量都由其子类继承。
默认访问修饰符意味着我们没有为类、字段、方法等显式声明访问修饰符。
没有任何访问控制修饰符声明的变量或方法可用于同一包中的任何其他类。 接口中的字段隐式为 public static final，接口中的方法默认为 public。
笔记
我们无法覆盖静态字段。如果您尝试覆盖它不会显示任何错误，但除了我们之外它不起作用。
http://docs.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html http://www.tutorialspoint.com/java/java_access_modifiers.htm
差异可以在已经提供的链接中找到，但使用哪个链接通常归结为“最少知识原则”。 只允许所需的最低可见性。
私人：仅限课堂访问
默认（无修饰符） ：对类和包的访问受限
Protected ：对类、包和子类（包内和包外）的有限访问
Public ：可访问类、包（所有）和子类......简而言之，无处不在。
Java 中的访问修饰符。
Java 访问修饰符用于在 Java 中提供访问控制。
1. 默认：
仅可访问同一包中的类。
例如，
// Saved in file A.java
package pack;
class A{
void msg(){System.out.println("Hello");}
}
// Saved in file B.java
package mypack;
import pack.*;
class B{
public static void main(String args[]){
A obj = new A(); // Compile Time Error
obj.msg(); // Compile Time Error
}
}
这种访问比公共和受保护的访问更受限制，但比私人的受限制更少。
2. 公开
可以从任何地方访问。 （全球访问）
例如，
// Saved in file A.java
package pack;
public class A{
public void msg(){System.out.println("Hello");}
}
// Saved in file B.java
package mypack;
import pack.*;
class B{
public static void main(String args[]){
A obj = new A();
obj.msg();
}
}
输出：你好
3. 私人
只能在同一班级内访问。
如果您尝试访问另一个类中一个类的私有成员，则会引发编译错误。 例如，
class A{
private int data = 40;
private void msg(){System.out.println("Hello java");}
}
public class Simple{
public static void main(String args[]){
A obj = new A();
System.out.println(obj.data); // Compile Time Error
obj.msg(); // Compile Time Error
}
}
4. 受保护
仅可访问同一包中的类和子类
例如，
// Saved in file A.java
package pack;
public class A{
protected void msg(){System.out.println("Hello");}
}
// Saved in file B.java
package mypack;
import pack.*;
class B extends A{
public static void main(String args[]){
B obj = new B();
obj.msg();
}
}
输出：你好
访问修饰符用于限制多个级别的访问。
公共：它基本上就像您可以从任何类访问一样简单，无论它是否在同一个包中。
要访问，如果您在同一个包中，您可以直接访问，但如果您在另一个包中，则可以创建该类的对象。
默认值：它可以在同一个包中的任何包类中访问。
要访问，您可以创建类的对象。 但是你不能在包外访问这个变量。
受保护：您可以访问同一包中的变量以及任何其他包中的子类。 所以基本上它是默认+继承行为。
要访问基类中定义的受保护字段，您可以创建子类的对象。
私有：它可以在同一个类中访问。
在非静态方法中，由于此引用（也在构造函数中），您可以直接访问，但要在静态方法中访问，您需要创建类的对象。
对包可见。 默认。 不需要修改器。
仅对班级可见（私人）。
对世界可见（ public ）。
对包和所有子类（ protected ）可见。
可以在不调用任何修饰符的情况下声明变量和方法。 默认示例：
String name = "john";
public int age(){
return age;
}
私有访问修饰符 - 私有：
声明为私有的方法、变量和构造函数只能在声明的类本身内访问。 私有访问修饰符是最严格的访问级别。 类和接口不能是私有的。
如果类中存在公共 getter 方法，则可以在类外访问声明为私有的变量。
使用私有修饰符是对象封装自身并向外界隐藏数据的主要方式。
例子：
Public class Details{
private String name;
public void setName(String n){
this.name = n;
}
public String getName(){
return this.name;
}
}
公共访问修饰符 - 公共：
可以从任何其他类访问声明为 public 的类、方法、构造函数、接口等。 因此，可以从属于 Java 世界的任何类访问公共类中声明的字段、方法和块。
但是，如果我们尝试访问的公共类在不同的包中，那么仍然需要导入公共类。
由于类继承，类的所有公共方法和变量都由其子类继承。
例子：
public void cal(){
}
受保护的访问修饰符 - 受保护：
在超类中声明为 protected 的变量、方法和构造函数只能由另一个包中的子类或受保护成员类的包内的任何类访问。
protected 访问修饰符不能应用于类和接口。 方法、字段可以声明为protected，但是接口中的方法和字段不能声明为protected。
受保护的访问使子类有机会使用辅助方法或变量，同时防止不相关的类尝试使用它。
class Van{
protected boolean speed(){
}
}
class Car{
boolean speed(){
}
}
公共- 从应用程序的任何地方访问。
默认- 可从包访问。
protected - 可以从包和其他包中的子类访问。 还有
private - 只能从它的类访问。
我只想解决一个非常普遍出错的细节，包括此页面上的大多数答案。 “默认”访问权限（不存在访问修饰符时）并不总是与package-private相同 。 这取决于事物是什么。
默认情况下，非成员类型（即未在另一种类型内声明的类，枚举，接口和注释类型）是程序包专用的。 （ JLS§6.6.1 ）
默认情况下，类成员和构造函数是包私有的。 （ JLS§6.6.1 ）
枚举构造函数默认是私有的 。 （实际上，枚举构造器必须是私有的，尝试将其公开或受保护是错误的）。 枚举常量是公共的，并且不允许任何访问说明符。 枚举的其他成员默认情况下是包私有的。 （ JLS§8.9 ）
默认情况下 ，接口和注释类型的所有成员都是公共的 。 （实际上，接口和注释类型的成员必须是公共的，并且尝试将它们设为私有或受保护是错误的。）（ JLS 9.3至9.5节 ）
....受保护：受保护的访问修饰符有点棘手，您可以说是默认访问修饰符的超集。 就同一包中的访问而言，受保护成员与默认成员相同。 不同之处在于，受保护的成员也可以被声明该成员的类的子类访问，这些子类在父类所在的包之外。
但是这些受保护的成员“只能通过继承在包外访问”。 即，您可以直接访问某个其他包中存在的其子类中的类的受保护成员，就好像该成员存在于子类本身中一样。 但是通过使用父类的引用，在包外的子类中将无法访问该受保护的成员。 ....
David 的回答提供了每个访问修饰符的含义。 至于何时使用每个类，我建议将所有类和每个类的供外部使用的方法（其 API）以及其他所有类设为公开。
随着时间的推移，您将了解何时将某些类设为包私有以及何时声明某些方法受保护以在子类中使用。
注意：这只是对已接受答案的补充。
这与 Java访问修饰符有关。
Java 访问修饰符指定哪些类可以访问给定的类及其字段、构造函数和方法。 可以为类、其构造函数、字段和方法单独指定访问修饰符。 Java 访问修饰符有时在日常用语中也称为 Java 访问说明符，但正确的名称是 Java 访问修饰符。 类、字段、构造函数和方法可以具有四种不同的 Java 访问修饰符之一：
- 项目清单
- 私人的
- 默认（包）
- 受保护
- 民众
从控制对班级成员的访问教程：
访问级别修饰符确定其他类是否可以使用特定字段或调用特定方法。 有两个级别的访问控制：
- 在顶层 — 公共或包私有（无显式修饰符）。
- 在成员级别——公共、私有、受保护或包私有（无显式修饰符）。
可以使用修饰符 public 声明一个类，在这种情况下，该类对任何地方的所有类都是可见的。 如果一个类没有修饰符（默认，也称为包私有），它只在它自己的包内可见
下表显示了每个修饰符允许的成员访问权限。
╔═════════════╦═══════╦═════════╦══════════╦═══════╗ ║ Modifier ║ Class ║ Package ║ Subclass ║ World ║ ╠═════════════╬═══════╬═════════╬══════════╬═══════╣ ║ public ║ Y ║ Y ║ Y ║ Y ║ ║ protected ║ Y ║ Y ║ Y ║ N ║ ║ no modifier ║ Y ║ Y ║ N ║ N ║ ║ private ║ Y ║ N ║ N ║ N ║ ╚═════════════╩═══════╩═════════╩══════════╩═══════╝第一个数据列指示类本身是否可以访问由访问级别定义的成员。 如您所见，类始终可以访问自己的成员。 第二列指示与该类位于同一包中的类（无论其出身如何）是否可以访问该成员。 第三列指示在此包外声明的类的子类是否可以访问该成员。 第四列指示是否所有类都可以访问该成员。
访问级别以两种方式影响您。 首先，当您使用来自其他来源的类（例如 Java 平台中的类）时，访问级别决定了您自己的类可以使用这些类的哪些成员。 其次，当你编写一个类时，你需要决定类中的每个成员变量和每个方法应该具有什么访问级别。
很多时候，我意识到可以通过创建现实世界的类比来记住任何语言的基本概念。 这是我理解 Java 中访问修饰符的类比：
假设您是一所大学的学生，您有一位朋友周末来看望您。 假设在校园中央有一尊大学创始人的大雕像。
当你把他带到校园时，你和你的朋友首先看到的就是这座雕像。 这意味着任何在校园内行走的人都可以在未经大学许可的情况下观看雕像。 这使得雕像成为PUBLIC 。
接下来，您想带您的朋友到您的宿舍，但为此您需要将他注册为访客。 这意味着他获得了进入校园的各种建筑物的通行证（与您的通行证相同）。 这将使他的门禁卡成为受保护的。
您的朋友想登录校园 WiFi，但没有任何凭据。 他可以上网的唯一方法是您与他分享您的登录信息。 （请记住，每个上大学的学生也都拥有这些登录凭据）。 这将使您的登录凭据成为NO MODIFIER 。
最后，您的朋友想阅读您发布在网站上的学期进度报告。 但是，每个学生都有自己的个人登录名来访问校园网站的这一部分。 这将使这些凭据成为PRIVATE 。
希望这可以帮助！
Public Protected Default 和 private 是访问修饰符。
它们用于封装或隐藏和显示类的内容。
Private 不能在类之外访问 Default 只能在包中访问。 在包以及扩展它的任何类中受保护。 公众对所有人开放。
通常，成员变量被定义为私有，但成员方法是公共的。
此图将使您轻松了解公共、私有、受保护和默认访问修饰符之间的基本区别。 当您没有在代码中声明 ant 访问修饰符时，默认修饰符会自动发生。
当您考虑访问修饰符时，只需以这种方式考虑它（适用于变量和方法）：
public --> 可从任何地方访问
private --> 只能在声明它的同一个类中访问
现在，当谈到default和protected时，就会出现混淆
default --> 不存在访问修饰符关键字。 这意味着它在类的包中严格可用。 在该包之外的任何地方都无法访问它。
protected --> 比default稍微宽松一点，除了相同的包类之外，它可以被它声明的包之外的子类访问。
我喜欢詹科夫的文章
下表总结了每个Java访问修饰符可以应用到的Java构造：
如果将方法或变量标记为私有（已为其分配了私有访问修饰符），则只有同一类内的代码才能访问该变量或调用该方法。 子类中的代码无法访问变量或方法，也不能从任何外部类中进行代码。
不能用私有访问修饰符标记类。 用private access修饰符标记一个类将意味着没有其他类可以访问它，这意味着您根本无法真正使用该类。 因此，不允许将私有访问修饰符用于类。
通过根本不编写任何访问修饰符来声明默认的Java访问修饰符。 默认访问修饰符意味着，类本身内部的代码以及与该类位于同一包中的类内部代码，都可以访问分配了默认访问修饰符的类，字段，构造函数或方法。 因此，默认访问修饰符有时也称为包访问修饰符。
受保护的访问修饰符提供与默认访问修饰符相同的访问权限，此外，子类可以访问超类的受保护方法和成员变量（字段）。 即使子类与超类不在同一个包中，也是如此。
Java访问修饰符public意味着所有代码都可以访问类，字段，构造函数或方法，而不管访问代码位于何处。 访问代码可以在不同的类和不同的包中。
我的两分钱:)
私人的：
类 ->顶级类不能是私有的。 内部类可以是私有的，可以从同一个类访问。
实例变量 ->只能在类中访问。 无法在课堂外访问。
包私有：
class ->顶级类可以是包私有的。 它只能从同一个包中访问。 不是来自子包，也不是来自外部包。
实例变量 ->可从同一个包访问。 不是来自子包，也不是来自外部包。
受保护：
类 ->无法保护顶级类。
实例变量 ->只能在同一个包或子包中访问。 扩展类时只能在包外访问。
民众：
类 ->可从包/子包/另一个包访问
实例变量 ->可从包/子包/另一个包访问
这里有详细解答
https://github.com/junto06/java-4-beginners/blob/master/basics/access-modifier.md
这完全是关于封装（或者正如乔菲利普斯所说，知识最少）。
从最严格的（私有）开始，然后看看您是否需要较少限制的修饰符。
我们都使用方法和成员修饰符，如 private、public 等，但开发人员很少做的一件事是使用包来逻辑地组织代码。
例如： 您可以将敏感的安全方法放在“安全”包中。 然后在这个包中放置一个访问一些安全相关代码的公共类，但将其他安全类包保持为私有。 因此，其他开发人员将只能使用此包外部的公共可用类（除非他们更改了修饰符）。 这不是安全功能，但会指导使用。
Outside world -> Package (SecurityEntryClass ---> Package private classes)
另一件事是，相互依赖程度很高的类最终可能会出现在同一个包中，并且如果依赖关系太强，最终可能会被重构或合并。
相反，如果您将所有内容都设置为public ，则将不清楚应该或不应该访问哪些内容，这可能会导致编写大量 javadoc（它不会通过编译器强制执行任何内容...）。
民众
如果一个类成员是用 public 声明的，那么它可以从任何地方访问
受保护
如果使用关键字 protected 声明类成员，则可以从相同的类成员、同一包内的外部类成员和继承的类成员访问它。 如果类成员受保护，则不能从外部包类访问它，除非外部打包类是继承的，即扩展了另一个包超类。 但是受保护的类成员始终可用于相同的包类，无论是否继承了相同的包类都无关紧要
默认
在 Java 中，默认值不是访问修饰符关键字。 如果声明的类成员没有任何访问修饰符关键字，那么在这种情况下，它被视为默认成员。 默认类成员始终可用于相同的包类成员。 但是即使外部类是与受保护成员不同的子类，外部包类成员也不能访问默认类成员
私人的
如果一个类成员是用关键字 protected 声明的，那么在这种情况下它只对相同的类成员可用
Java 中的访问说明符：Java 中有 4 个访问说明符，分别是 private、package-private（默认）、protected 和 public，按访问顺序递增。
Private ：当您正在开发某个类并且您希望该类的成员不被暴露在该类之外时，您应该将其声明为私有。 私有成员只能在定义它们的类中访问，即封闭类。 私有成员可以在“this”引用上访问，也可以在包含这些成员的其他类实例上访问，但只能在此类的定义内访问。
Package-private（默认） ：除了下面描述的访问之外，这个访问说明符将提供由私有访问说明符指定的访问。
当您开发某个包以及其中的某个类（例如 Class1）时，您可以使用默认（无需明确提及）访问说明符，将类中的成员暴露给（相同）包中的其他类。 在这些其他类（在同一个包中）中，您可以访问 Class1 实例上的这些默认成员。 您还可以在 Class1 的子类中访问这些默认成员，例如 Class2（在此引用或 Class1 的实例或 Class2 的实例上）。
基本上，在同一个包中，您可以直接访问类实例上的默认成员或子类中的“this”引用。
protected ：除了下面描述的访问之外，此访问说明符将提供由包私有访问说明符指定的访问。
当您正在开发某个包以及其中的某个类（例如 Class1）时，如果您不希望在您的包外访问此成员（例如在消费者的包中），则您应该对 Class1 中的数据成员使用受保护的访问说明符您的包，即正在使用您的 API 的客户端），但您希望例外，并且仅当客户端编写扩展 Class1 的类 Class2 时才允许访问此成员。 因此，一般来说，受保护的成员可以在派生类（即 Class2）中的“this”引用上访问，也可以在 Class2 的显式实例上访问。
请注意：
所以底线是，受保护的成员可以在其他包中访问，只有当来自这个其他包的某个类，扩展包含此受保护成员和受保护成员的类时，才能在“this”引用或扩展类的显式实例上访问，在扩展的定义内班级。
public ：除了下面描述的访问之外，此访问说明符将提供受保护访问说明符指定的访问。
当您正在开发某个包以及其中的某个类（比如 Class1）时，如果您希望该成员可以在 Class1 的其他包中的其他包中访问，那么您应该对 Class1 中的数据成员使用公共访问说明符。包裹。 基本上，当您打算在没有任何条件的情况下向世界公开您的数据成员时，应该使用此访问说明符。
Java 中有两种修饰符：访问修饰符和非访问修饰符。
Java 中的访问修饰符指定字段、方法、构造函数或类的可访问性或范围。 我们可以通过对其应用访问修饰符来更改字段、构造函数、方法和类的访问级别。
Java 访问修饰符有四种类型：
私有访问修饰符只能在类中访问。
私有访问修饰符示例
在这个例子中，我们创建了两个类 PrivateDemo 和 Main。 PrivateDemo 类包含私有数据成员和私有方法。 我们正在从类外部访问这些私有成员，因此存在编译时错误。
class PrivateDemo {
private int data=999;
private void message(){System.out.println("I am private a method");}
}
public class Main{
public static void main(String args[]){
PrivateDemo obj=new PrivateDemo();
System.out.println(obj.data); //Compile Time Error
obj.message(); //Compile Time Error
}
}
注意如果您将任何类构造函数设为私有，则无法从类外部创建该类的实例。
protected 访问修饰符可以在包内和包外访问，但只能通过继承访问。
protected 访问修饰符可以应用于数据成员、方法和构造函数。 不能应用于课堂。
它提供了比默认修改器更多的可访问性。
受保护的访问修饰符示例
在本例中，我们创建了两个包 com.protectedone.ex 和 com.protectedtwo.ex。 com.protectedone.ex 包的 ProtectedOne 类是公共的，因此可以从包外部访问。 但是这个包的message方法被声明为protected，所以只能通过继承从类外访问。
//save by ProtectedOne.java
package com.protectedone.ex;
public class ProtectedOne {
protected void message(){System.out.println("I am a protected method");}
}
//save by ProtecteTwo.java
package com.protectedtwo.ex;
import com.protectedone.ex.*;
class ProtectedTwo extends ProtectedOne{
public static void main(String args[]){
ProtectedTwo obj = new ProtectedTwo();
obj.message();
}
}
输出::
I am a protected method
公共访问修饰符可在任何地方访问。 在所有其他修饰符中，它的范围最广。
公共访问修饰符示例
//save by PublicOne.java
package com.publicone.ex;
public class PublicOne {
public void message(){System.out.println("I am a public method");}
}
//save by PublicTwo.java
package com.publictwo.ex;
import com.publicone.ex.*;
class PublicTwo extends PublicOne{
public static void main(String args[]){
PublicOne obj = new PublicOne();
obj.message();
}
}
输出::
I am a public method
如果不使用任何修饰符，则默认将其视为默认值。 默认修饰符只能在包内访问。 无法从包外部访问它。 它提供了比私有更多的可访问性。 但是，它比受保护和公开更具限制性。
默认访问修饰符示例
在这个例子中，我们创建了两个包 com.defaultone.ex 和 com.defaulttwo.ex。 我们从它的包外部访问 DefaultOne 类，因为 DefaultOne 类不是公共的，所以不能从包外部访问它。
//save by DefaultOne.java
package com.defaultone.ex;
public class DefaultOne {
void message(){System.out.println("I am a default method");}
}
//save by DefaultTwo.java
package com.defaulttwo.ex;
import com.defaultone.ex.*;
class PublicTwo {
public static void main(String args[]){
PublicOne obj = new PublicOne(); //Compile Time Error
obj.message(); //Compile Time Error
}
}
在上面的示例中，类 DefaultOne 及其方法 message() 的范围是默认的，因此无法从包外部访问它。
Private ：我们可以访问类中的私有成员。 它们不能在类之外访问。 我们可以将变量、方法和构造函数声明为私有的。 但是我们不能将顶级类设为私有。
默认值：如果我们没有在变量、方法或构造函数前面指定任何访问修饰符，那么它被视为默认访问修饰符。 我们只能在类和包中访问默认成员。 我们无法在包之外访问它们。
受保护：我们可以使用受保护的关键字将成员声明为受保护的。 我们可以访问类内、包内和包外子类中的受保护成员。
Public ：我们可以使用 public 关键字将成员声明为 public。 我们可以访问任何类或任何包中的公共成员。 对公共成员的可访问性没有限制。
您可以在此处了解有关 java 中的访问修饰符的更多信息： https<\/a> :\/\/getinputs.com\/access-modifiers-in-java\/
在谈论访问修饰符时，我们可以很容易理解，非常简单的规则包括它们。
私有访问修饰符用于： - 仅同一个类
默认访问修饰符用于： - 仅相同的类/相同的包子类
受保护的访问修饰符用于： - 相同的类/相同的包子类/相同的包非子类/不同的包子类
公共访问修饰符用于：- 我们可以在任何地方使用（相同的类/相同的包子类/相同的包非子类/不同的包子类/不同的包非子类）
对于初学者来说，考虑这个例子可能会有所帮助；
考虑一下我在foo package 中开发了MyClass并且它有一个名为print的奇妙方法，您有兴趣调用它（它可以是method或property ）
package foo; // I am in foo
public class MyClass {
private void print() { //This is private
System.out.println("I can print!");
}
}
你在package bar开发了YourClass ，有兴趣使用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();
}
}
您的代码未编译并且出现错误The method print() is undefined for the type MyClass
你过来我这里：
private的。 可以public吗？others使用它not others用吧。private关键字。 我的访问修饰符将是default或private package 。 因为你是我的朋友，你必须和我在同一个 package。 所以你must来我的 package foo 。 我的意思是确切的 package 甚至不是子 package。 然后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();
}
}
别想了：你又来找我了
extend我，我让print() protected ，那么你可以使用它，无论你是否更改 package。 这是我的MyClass
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();
}
}
当您不希望您的变量/方法/类在该类之外可见时，请使用私有。 当您希望只有此类的孩子可以使用该变量时，请使用 protected。 当您希望变量/类/方法应该可以从任何地方访问时，请使用 public。 当您希望您的变量/类/方法仅在该包内使用时，请使用包私有。
受保护和程序包专用（无修饰符）构造函数之间的区别？
[英]Difference between a protected and package-private (no modifier) constructor?
Java如何保护私有变量，程序包私有变量和受保护变量？
[英]How does Java protect private, package-private, and protected variables?
声明:本站的技术帖子网页，遵循CC BY-SA 4.0协议，如果您需要转载，请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.