Question

在Java中，是否有明确规定何时使用每个访问修饰符，即默认（包私有），public，protected和private，同时使{{1和} class并处理继承？

Answer 1

            │ Class │ Package │ Subclass │ Subclass │ World
            │       │         │(same pkg)│(diff pkg)│ 
────────────┼───────┼─────────┼──────────┼──────────┼────────
public      │   +   │    +    │    +     │     +    │   +     
────────────┼───────┼─────────┼──────────┼──────────┼────────
protected   │   +   │    +    │    +     │     +    │         
────────────┼───────┼─────────┼──────────┼──────────┼────────
no modifier │   +   │    +    │    +     │          │    
────────────┼───────┼─────────┼──────────┼──────────┼────────
private     │   +   │         │          │          │    

 + : accessible         blank : not accessible

Answer 2

（警告：我不是Java程序员，我是Perl程序员.Perl没有正式的保护，这也许就是我理解这个问题的原因:)）

私人

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

Package Private

只能在声明它的包中查看和使用。这是Java中的默认值（有些人认为是错误的。）

受保护的

包私有+可以通过子类或包成员看到。

公共

每个人都可以看到它。

Published

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

C ++定义了一个名为“friend”的附加级别，你知道的越少越好。

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

因此，经验法则是将事物视为必须可见。从私有开始，只根据需要添加更多可见性。只公开那些对用户来说绝对必要的信息，你公开的每一个细节都会让你重新设计系统。

如果您希望用户能够自定义行为，而不是将内部公开，以便他们可以覆盖它们，那么将这些内容推入对象并公开该接口通常是更好的主意。这样他们就可以简单地插入一个新对象。例如，如果您正在编写CD播放器并希望“查找有关此CD的信息”位可自定义，而不是将这些方法公开，您可以将所有功能放入其自己的对象中，并使公共getter / setter成为公共对象。通过这种方式吝啬暴露你的胆量可以促进良好的成分和关注点的分离

就个人而言，我只坚持“私人”和“公开”。许多OO语言就是这样。 “受保护”可以派上用场，但这真的是一种骗局。一旦界面不仅仅是私人的，它就在你的控制之外，你必须去寻找其他人的代码才能找到用途。

这就是“已发布”的概念所在。更改界面（重构它）需要您找到使用它的所有代码并进行更改。如果界面是私有的，那么没问题。如果它受到保护，你必须找到你所有的子类。如果它是公开的，你必须找到使用你的代码的所有代码。有时这是可能的，例如，如果您正在处理仅供内部使用的公司代码，那么如果接口是公共的则无关紧要。您可以从公司存储库中获取所有代码。但是如果一个界面被“发布”，如果有代码在你的控制范围之外使用它，那么你就被软管了。您必须支持该接口或冒险破坏代码。甚至受保护的接口也可以被认为是已发布的（这就是我不打扰受保护的原因）。

许多语言发现公共/受保护/私有的层次性过于限制，与现实不符。为此，有一个trait class的概念，但这是另一个节目。

Answer 3

这是表格的更好版本。（模块专栏的未来证明。）

说明

私有成员（i）只能在与宣布相同的类中访问。
无访问修饰符（j）的成员只能在同一个包中的类中访问。
受保护的成员（k）可以在其他包的子类中的同一个包和中的所有类中访问。
所有类都可以访问 public 成员（l）（除非它位于不导出声明的包的module中）

选择哪种修改器？

访问修饰符是一种帮助您防止意外破坏封装^（*）的工具。问问自己，您是否希望该成员成为类，包，类层次结构内部的内容，或者根本不是内部成员，并相应地选择访问级别。

<强>示例：

字段long internalCounter应该是私有的，因为它是可变的和实现细节。
只应在工厂类（在同一个包中）实例化的类应该有一个包受限制的构造函数，因为它不应该直接从包外部调用它。
应该保护在呈现之前调用并在子类中用作钩子的内部void beforeRender()方法。
从GUI代码调用的void saveGame(File dst)方法应该是公共的。

^{（*）What is Encapsulation exactly?}

Answer 4

                | 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         |       ✔       |     ✘     |       ✘       |   ✘

Answer 5

简单的规则。首先声明一切都是私密的。然后随着需求的出现向公众发展，设计需要保证。

当暴露成员时，问问自己是否暴露了表示选择或抽象选择。第一个是你想要避免的东西，因为它会在实际表示中引入太多依赖，而不是它的可观察行为。

作为一般规则，我尝试通过子类化来避免重写方法实现;搞砸逻辑太容易了。如果您打算覆盖它，则声明抽象受保护的方法。

另外，在重写时使用@Override注释可以防止在重构时破坏。

Answer 6

实际上比简单的网格显示要复杂一些。网格告诉您是否允许访问，但是访问的确切构成是什么？此外，访问级别以复杂的方式与嵌套类和继承交互。

“默认”访问权限（由缺少关键字指定）也称为package-private。例外：在界面中，没有修饰符意味着公共访问;禁止公开以外的修饰语。枚举常量总是公开的。

摘要

是否允许访问具有此访问说明符的成员？

成员为private：仅当成员与调用代码在同一类中定义时才会发生。
成员是包私有：仅当主叫代码位于成员的立即封装包内时。
成员是protected：相同的包，或者如果成员是在包含调用代码的类的超类中定义的。
会员是public：是的。

哪些访问说明符适用于

局部变量和形式参数不能使用访问说明符。由于根据范围规则它们本身就无法进入外部，因此它们实际上是私密的。

对于顶级作用域中的类，仅允许public和package-private。这种设计选择可能是因为protected和private在包级别是多余的（没有包的继承）。

所有访问说明符都可以在类成员（构造函数，方法和静态成员函数，嵌套类）上使用。

顺序

访问说明符可以严格排序

公开＆gt;受保护的＆gt; package-private＆gt;私人

意味着public提供的访问权限最多，private最少。私有成员可能的任何引用也对包私有成员有效;对包私有成员的任何引用在受保护的成员上都是有效的，依此类推。（允许访问受保护的成员到同一个包中的其他类被认为是一个错误。）

备注

A class's methods are allowed to access private members of other objects of the same class.更确切地说，C类的方法可以访问C的任何子类的对象上的C的私有成员.Java不支持通过实例限制访问，仅限于类。（与Scala比较，后者使用private[this]支持它。）
您需要访问构造函数才能构造对象。因此，如果所有构造函数都是私有的，则该类只能由生活在类中的代码构造（通常是静态工厂方法或静态变量初始化器）。类似地，对于包私有或受保护的构造函数。
- 只有私有构造函数也意味着该类不能在外部进行子类化，因为Java需要子类的构造函数来隐式或显式地调用超类构造函数。（但是，它可以包含一个嵌套类，它将其子类化。）

内部课程

您还必须考虑嵌套范围，例如内部类。复杂性的一个例子是内部类具有成员，这些成员本身可以使用访问修饰符。所以你可以拥有一个公共成员的私人内部阶级;会员可以访问吗？（见下文。）一般规则是查看范围并递归思考，看看是否可以访问每个级别。

然而，这非常复杂，详情请consult the Java Language Specification。（是的，过去有过编译器错误。）

要了解这些如何相互作用，请考虑此示例。有可能“泄漏”私人内部阶级;这通常是一个警告：

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

一些相关问题：

Java - Method accessibility inside package-private class?

Answer 7

根据经验：

private：班级范围。
default（或package-private）：包范围。
protected：package scope + child（与包一样，但我们可以从不同的包中继承它）。 protected修饰符始终保持“父子关系”。
public：无处不在。

因此，如果我们将访问权限分为三个权利：

（D）irect （从同一个班级内的方法调用）。
（R）eference （使用对类的引用或“dot”语法调用方法）。
（I）nheritance （通过子类化）。

然后我们有了这个简单的表格：

+—-———————————————+————————————+———————————+
|                 |    Same    | Different |
|                 |   Package  | Packages  |
+—————————————————+————————————+———————————+
| private         |   D        |           |
+—————————————————+————————————+———————————+
| package-private |            |           |
| (no modifier)   |   D R I    |           |
+—————————————————+————————————+———————————+
| protected       |   D R I    |       I   |
+—————————————————+————————————+———————————+
| public          |   D R I    |    R  I   |
+—————————————————+————————————+———————————+

Answer 8

非常短暂

public：无处不在。
protected：可由同一个包的类和驻留在任何包中的子类访问。
默认值（未指定修饰符）：可由同一包的类访问。
private：只能在同一个班级内访问。

Answer 9

Java中最容易被误解的访问修饰符是protected。我们知道它与默认修饰符类似，但有一个例外，即子类可以看到它。但是怎么样？这是一个有希望澄清混淆的例子：

假设我们有2个班级; Father和Son，每个都在自己的包中：

package fatherpackage;

public class Father
{

}

-------------------------------------------

package sonpackage;

public class Son extends Father
{

}

我们将受保护的方法foo()添加到Father。

package fatherpackage;

public class Father
{
    protected void foo(){}
}

可以在4个上下文中调用方法foo()：

位于定义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 } }

Answer 10

<强>私人

方法，变量和构造函数

声明为private的方法，变量和构造函数只能在声明的类本身中访问。

类和接口

私有访问修饰符是限制性最强的访问级别。类和接口不能是私有的。

<强> 注意

如果类中存在公共getter方法，则可以在类外部访问声明为private的变量。在超类中声明受保护的变量，方法和构造函数只能由其他包中的子类或受保护成员的包中的任何类访问。类。

<小时/>

<强>受保护的

类和接口

受保护的访问修饰符不能应用于类和接口。

方法，字段可以声明为受保护，但接口中的方法和字段不能声明为受保护。

<强> 注意

受保护的访问权使子类有机会使用辅助方法或变量，同时防止非相关类尝试使用它。

<小时/>

公开

可以从任何其他类访问声明为public的类，方法，构造函数，接口等。

因此，可以从属于Java Universe的任何类访问在公共类中声明的字段，方法，块。

不同的套餐

但是，如果我们尝试访问的公共类位于不同的包中，则仍需要导入公共类。

由于类继承，类的所有公共方法和变量都由其子类继承。

<小时/>

默认-No关键字：

默认访问修饰符意味着我们没有为类，字段，方法等显式声明访问修饰符。

在相同的包中

在没有任何访问控制修饰符的情况下声明的变量或方法可用于同一包中的任何其他类。接口中的字段是隐式公共静态final，接口中的方法默认是公共的。

<强> 注意

我们无法覆盖静态字段。如果您尝试覆盖它，则不会显示任何错误但它不起作用我们除外。

相关答案

Overriding static methods in java

参考链接

http://docs.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html http://www.tutorialspoint.com/java/java_access_modifiers.htm

Answer 11

私人：仅限课堂访问权限

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

受保护：对类，包和子类（包内和包外）的有限访问权限

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

Answer 12

差异可以在已经提供的链接中找到，但使用哪个通常归结为“最少知识原则”。只允许所需的最低可见性。

Answer 13

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(); } }

输出：你好

Answer 14

访问修饰符用于限制多个级别的访问。

公开：它基本上就像您可以从任何类访问一样简单，无论它是否在同一个包中。

如果您在同一个包中，可以直接访问，但如果您在另一个包中，则可以创建该类的对象。

默认值：可以从任何类包中的同一个包中访问它。

要访问，您可以创建该类的对象。但是你不能在包外面访问这个变量。

受保护：您可以访问同一个包中的变量以及任何其他包中的子类。所以基本上它是默认+继承行为。

要访问基类中定义的受保护字段，您可以创建子类的对象。

私有：可以在同一个类中访问。

在非静态方法中，您可以直接访问因为 this 引用（也在构造函数中），但要在静态方法中访问，您需要创建类的对象。

Answer 15

包装可见。默认。不需要修饰符。

仅对班级可见（私人）。

向全世界展示（公开）。

对包和所有子类（受保护的）可见。

可以声明变量和方法，而不需要调用任何修饰符。默认示例：

String name = "john";

public int age(){
    return age;
}

私人访问修饰符 - 私有：

声明为private的方法，变量和构造函数只能在声明的类本身中访问。私有访问修饰符是限制性最强的访问级别。类和接口不能是私有的。

如果类中存在公共getter方法，则可以在类外部访问声明为private的变量。

使用private修饰符是对象封装自身并隐藏来自外部世界的数据的主要方式。

示例：

Public class Details{

    private String name;

    public void setName(String n){
        this.name = n;
    }

    public String getName(){
        return this.name;
    }
}

公共访问修饰符 - public：

声明为public的类，方法，构造函数，接口等可以从任何其他类访问。因此，可以从属于Java Universe的任何类访问在公共类中声明的字段，方法，块。

但是，如果我们尝试访问的公共类位于不同的包中，则仍需要导入公共类。

由于类继承，类的所有公共方法和变量都由其子类继承。

示例：

public void cal(){

}

受保护的访问修饰符 - 受保护：

在超类中声明受保护的变量，方法和构造函数只能由另一个包中的子类或受保护成员类的包中的任何类访问。

受保护的访问修饰符无法应用于类和接口。方法，字段可以声明为protected，但是接口中的方法和字段不能声明为protected。

受保护的访问权使子类有机会使用辅助方法或变量，同时防止非相关类尝试使用它。

class Van{

    protected boolean speed(){

    }
}

class Car{
    boolean speed(){
    }

}

Answer 16

我只是想解决一个极其普遍错误的细节，包括本页面上的大部分答案。 “默认”访问（当不存在访问修饰符时）并不总是与package-private相同。这取决于事物是什么。

默认情况下，非成员类型（即未在其他类型中声明的类，枚举，接口和注释类型）是package-private。（JLS §6.6.1）
默认情况下，类成员和构造函数是包私有的。（JLS §6.6.1）
默认情况下，枚举构造函数私有。（实际上，枚举结构必须是私有的，尝试使它们公开或受保护是错误的）。枚举常量是公共的，不允许任何访问说明符。枚举的其他成员默认为package-private。（JLS §8.9）
界面和注释类型的所有成员默认为公开。（实际上，接口和注释类型的成员必须是公开的，尝试将它们设为私有或受保护是错误的。）（JLS §9.3 to 9.5）

Answer 17

公开 - 可从应用程序的任何位置访问。
默认 - 可从包中访问。
受保护 - 可从其他包中的包和子类访问。
私人 - 仅可从其班级访问。

Answer 18

This page writes well about the protected & default access modifier

.... 受保护：受保护的访问修饰符有点棘手，你可以说是默认访问修饰符的超集。受保护的成员与默认成员相同，只要涉及相同包中的访问。不同之处在于，受保护成员也可以被声明成员的类的子类访问，这些成员位于父类所在的包之外。

但是这些受保护的成员“只能通过继承才能在程序包外部访问”。即，您可以直接访问其他包中存在的子类中受保护的成员，就好像该成员存在于子类本身中一样。但是，通过使用父类的引用，无法在包外部的子类中访问该受保护的成员。 ....

Answer 19

David的回答提供了每个访问修饰符的含义。至于何时使用每一个，我建议公开所有类和每个类的方法，以供外部使用（其API），其他一切都是私有的。

随着时间的推移，您将了解何时将某些类包装为私有以及何时声明某些受保护以供子类使用的方法。

Answer 20

注意：这只是接受答案的补充。

这与Java Access Modifiers。

有关

来自Java Access Modifiers：

Java访问修饰符指定哪些类可以访问给定的   类及其字段，构造函数和方法。访问修饰符可以   为类，其构造函数，字段和单独指定   方法。 Java访问修饰符有时也在日常中被引用   语音作为Java访问说明符，但正确的名称是Java访问   改性剂。类，字段，构造函数和方法可以有一个   四种不同的Java访问修饰符：


列表项

私有

默认（包）

保护

公共

来自Controlling Access to Members of a Class教程：

访问级别修饰符确定其他类是否可以使用   特定字段或调用特定方法。有两个级别   访问控制：


在顶层 - public或package-private（无显式修饰符）。

在成员级别 - public，private，protected或package-private（无显式修饰符）。


可以使用修饰符public声明一个类，在这种情况下   所有类都可以看到类。如果一个类没有修饰符   （默认值，也称为package-private），它只是可见的   在自己的包中

下表显示了每个成员允许的成员访问权限   改性剂。
╔═════════════╦═══════╦═════════╦══════════╦═══════╗
║ 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     ║
╚═════════════╩═══════╩═════════╩══════════╩═══════╝
第一个数据列表明类本身是否可以访问   由访问级别定义的成员。如你所见，一个班级总是如此   可以访问自己的成员。第二列表示是否   类与同一个包在同一个包中（不管它们是什么类   parentage）可以访问该成员。第三栏表明   是否在此包外声明的类的子类   访问该成员。第四列表示是否所有类   有权访问该会员。

访问级别会以两种方式影响您。首先，当你使用那些类时   来自其他来源，例如Java平台中的类，   访问级别确定您自己的那些类的成员   课程可以使用。第二，当你写一堂课时，你需要决定   每个成员变量和类中的每个方法的访问级别   应该有。

Answer 21

Public Protected Default和private是访问修饰符。

它们用于封装，或隐藏和显示类的内容。

班级可以是公开的或默认的
班级成员可以是公开的，受保护的，默认的或私人的。

私人课程无法在课堂外访问默认只能在包中访问。受保护的包以及任何扩展它的类。公众对所有人开放。

通常，成员变量是私有的，但成员方法是公共的。

Answer 22

我经常意识到，通过创造现实世界的类比，记住任何语言的基本概念都是可能的。以下是我在Java中理解访问修饰符的类比：

我们假设您是一所大学的学生，并且您有一位朋友将在周末来访您。假设校园中间有一座大学创始人的大型雕像。

当你把他带到校园时，你和你朋友看到的第一件事就是这座雕像。这意味着任何走进校园的人都可以在未经大学许可的情况下观看雕像。这使雕像成为 PUBLIC 。
接下来，您想带上您的朋友到您的宿舍，但为此您需要将他注册为访客。这意味着他可以获得进入通行证（与您的通行证相同）进入校园内的各种建筑物。这会使他的访问卡成为 PROTECTED 。
您的朋友想要登录校园WiFi，但没有任何凭据可以登录。他上网的唯一方法就是与他分享您的登录信息。（请记住，每个上大学的学生也拥有这些登录凭据）。这会使您的登录凭据为 NO MODIFIER 。
最后，您的朋友想要阅读您在网站上发布的学期的进度报告。但是，每个学生都有自己的个人登录信息，可以访问校园网站的这一部分。这会将这些凭据设为 PRIVATE 。

希望这有帮助！

Answer 23

当您考虑访问修饰符时，只需以这种方式考虑它（适用于变量和方法）：

public - ＆gt;从每个地方都可以访问 private - ＆gt;只能在声明它的同一个类中访问

现在，default和protected

出现了混乱

default - ＆gt;不存在访问修饰符关键字。这意味着它严格适用于该类包。无处在该软件包之外，可以访问它。

protected - ＆gt;略微不如default严格，除了相同的包类，它可以被包之外的子类访问，它被声明。

Answer 24

此图像将使您轻松了解public，private，protected和default访问修饰符之间的基本区别。当您未在代码中声明蚂蚁访问修饰符时，默认修饰符会自动发生。

Answer 25

所有关于封装（或正如Joe Phillips所述，最少知识）。

从限制性最强的（私有）开始，看看以后是否需要限制较少的修饰符。

我们都使用方法和成员修饰符，例如private，public，...但是开发人员做的一件事就是使用包来逻辑地组织代码。

例如：您可以将敏感的安全方法放在“安全”包中。然后放一个公共类来访问此包中的一些安全相关代码，但保留其他安全类 package private 。因此，其他开发人员只能使用此包之外的公共类（除非他们更改修饰符）。这不是安全功能，但指导用法。

Outside world -> Package (SecurityEntryClass ---> Package private classes)

另一件事是，彼此依赖很多的类可能最终会出现在同一个包中，如果依赖性太强，最终可能会被重构或合并。

如果恰恰相反，您将所有内容设置为 public ，则不清楚应该或不应该访问的内容，这可能会导致编写大量javadoc（不会通过编译器执行任何操作） ...）。

Answer 26

访问修饰符

我喜欢Jenkov's article

下表总结了每个Java访问修饰符可以应用于哪些Java构造：

私人

如果将一个方法或变量标记为私有（已为其分配了私有访问修饰符），则只有同一类内的代码才能访问该变量或调用该方法。子类中的代码无法访问变量或方法，也不能从任何外部类中进行代码。

不能用私有访问修饰符标记类。用private access修饰符标记一个类将意味着没有其他类可以访问它，这意味着您根本无法真正使用该类。因此，不允许将私有访问修饰符用于类。

默认

通过完全不编写任何访问修饰符来声明默认的Java访问修饰符。默认访问修饰符意味着，类本身内部的代码以及与该类位于同一包中的类内部代码，都可以访问分配了默认访问修饰符的类，字段，构造函数或方法。因此，默认访问修饰符有时也称为包访问修饰符。

受保护的

受保护的访问修饰符提供与默认访问修饰符相同的访问权限，此外，子类可以访问超类的受保护方法和成员变量（字段）。即使子类与超类不在同一个包中，也是如此。

公开

Java访问修饰符public意味着所有代码都可以访问类，字段，构造函数或方法，而不管访问代码位于何处。访问代码可以在不同的类和不同的包中。

Answer 27

我的两分钱：）

私人：

class-> 顶级类不能为私有。内部类可以是私有的，可以从同一类访问。

实例变量-> 仅在类中可访问。无法在课程外访问。

包私有：

class-> 顶级类可以是程序包私有的。只能从同一软件包访问它。不是来自子包装，不是来自外部包装。

实例变量-> 可从同一程序包访问。不是来自子包装，不是来自外部包装。

受保护的：

class-> 顶级类不能受到保护。

实例变量-> 仅可在同一程序包或子程序包中访问。扩展类时只能在包外部访问。

公开：

class-> 可从包/子包/另一个包中访问

实例变量-> 可从程序包/子程序包/另一个程序包中访问

这是详细的答案

https://github.com/junto06/java-4-beginners/blob/master/basics/access-modifier.md

Answer 28

公开

如果一个类成员是公开声明的，则可以从任何地方访问它
受保护的

如果使用关键字protected声明了类成员，则可以从相同的类成员，同一包中的外部类成员以及继承的类成员访问它。如果一个类成员受到保护，那么除非从外部打包的类继承，即不能扩展另一个包的超类，否则不能从外部的包类访问它。但是受保护的类成员始终可用于相同的包类，无论继承还是不继承相同的包类都没关系
默认

在Java中，默认不是访问修饰符关键字。如果声明的类成员没有任何访问修饰符关键字，则在这种情况下，它将被视为默认成员。默认的类成员始终可用于相同的包类成员。但是，即使外部类是不同于受保护成员的子类，外部包类成员也无法访问默认类成员
私人

如果用关键字保护声明了类成员，那么在这种情况下，只有同一个类成员才可以使用

Answer 29

以下框图说明了当派生类访问方式为私有时，如何继承基类的数据成员

注意：使用私有访问说明符声明数据成员称为数据隐藏。

来源： Access Specifiers – Private, Public and Protected

Answer 30

Java访问权限修改了您可以使用的

Answer 31

Java中的访问说明符： java中有4个访问说明，即访问顺序递增的私有，程序包私有（默认），受保护和公开。

私有：当您正在开发某个类并希望该类的成员不暴露于此类之外时，则应将其声明为私有。私有成员只能在定义了私有成员的类（即封闭类）中访问。可以在“此”引用以及包含这些成员的类的其他实例上访问私有成员，但只能在此类的定义内进行访问。

私有软件包（默认）：除了以下所述的访问之外，此访问说明还将提供由私有访问说明指定的访问。

在开发某个包并在其中开发某个类（例如Class1）时，可以使用默认的（不需要明确提及）访问说明符，将类中的成员公开给（相同）包中的其他类。在这些其他类（在同一包中）中，您可以在Class1的实例上访问这些默认成员。您还可以访问Class1的子类（例如Class2）中的这些默认成员（在此引用上或在Class1的实例上或在Class2的实例上）。

基本上，在同一包中，您可以直接在类的实例上或在子类中的此引用上访问默认成员。

受保护的：除了下面描述的访问之外，该访问说明还将提供包专用访问说明所指定的访问。

在开发某个包并在其中开发某个类（例如Class1）时，如果您不希望在包外部访问该成员（例如，在包中），则应该对Class1中的数据成员使用受保护的访问说明符通常是您的程序包的使用方，即使用API的客户端），但您要例外，并且仅当客户端编写扩展Class1的类Class2时才允许访问此成员。因此，通常，在派生类（即Class2）中的“ this”引用上，以及在Class2的显式实例上，都可以访问受保护的成员。

请注意：

您将无法访问以下类别中继承的Class1的受保护成员： Class2，如果您尝试在Class1的显式实例上访问它，尽管它是在其中继承的。
当您在相同/不同的包中编写另一个类Class3时扩展了Class2，则可以访问Class1的受保护成员在此参考上以及在Class3的显式实例上。这将对于任何扩展的层次结构（即受保护的成员）为true 在此参考或扩展实例上仍可访问类。请注意，在Class3中，如果您创建Class2的实例，则您将无法通过Class1访问受保护的成员它是继承的。

因此，最重要的是，只有当其他包中的某个类扩展了包含该受保护成员的类，并且在扩展类定义内的扩展类的此引用或显式实例上允许这种访问时，才可以在其他包中访问受保护成员

公共：除了以下所述的访问权限之外，此访问权限说明符还将提供受保护的访问权限说明符指定的访问权限。

在开发某个包并在其中开发某个类（例如Class1）时，如果要在某个包中创建的Class1实例的其他包中可以访问该成员，则应该对Class1中的数据成员使用公共访问说明符其他包的类。基本上，当您打算无条件将数据成员暴露给世界时，应使用此访问说明符。

Java中的public，protected，package-private和private有什么区别？

31 个答案:

私人

Package Private

受保护的

公共

Published

说明

选择哪种修改器？

摘要

哪些访问说明符适用于

顺序

备注

内部课程

<强>私人

<强>受保护的

公开

默认-No关键字：

相关答案

参考链接

访问修饰符

私人

默认

受保护的

公开