在Java中，公共的、受保护的、包私有的和私有的有什么区别？


What is the difference between public, protected, package-private and private in Java?

在爪哇，有明确的规则何时使用每个访问修饰符，即默认(包私有)、EDCOX1、0、EDCOX1、1和EDCX1×2，同时使EDCOX1为3，EDCX1为4，并处理继承。

相关讨论

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

1
2
3
4
5
6
7
8
9
10
11
12
            │ Class │ Package │ Subclass │ Subclass │ World
            │       │         │(same pkg)│(diff pkg)│
────────────┼───────┼─────────┼──────────┼──────────┼────────
public      │   +   │    +    │    +     │     +    │   +    
────────────┼───────┼─────────┼──────────┼──────────┼────────
protected   │   +   │    +    │    +     │     +    │        
────────────┼───────┼─────────┼──────────┼──────────┼────────
no modifier │   +   │    +    │    +     │          │    
────────────┼───────┼─────────┼──────────┼──────────┼────────
private     │   +   │         │          │          │    

 + : accessible         blank : not accessible
相关讨论

(我不是Java程序员，我是Perl程序员。Perl没有正式的保护，这也许就是为什么我能很好地理解这个问题的原因：)

私人的

正如您所想，只有声明它的类才能看到它。

私人包

只能由声明它的包看到和使用。这是Java中的缺省(有些人认为这是一个错误)。

受保护的

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

公众

每个人都能看到。

出版

在代码I控件之外可见。(虽然不是Java语法，但这一讨论很重要)。

C++定义了一个称为"朋友"的附加级别，你知道的越少越好。

什么时候用什么？整个想法是封装以隐藏信息。尽可能多地隐藏如何对用户进行操作的细节。为什么？因为你可以在以后更改它们，而不会破坏任何人的代码。这使您可以优化、重构、重新设计和修复bug，而不用担心有人正在使用您刚刚大修的代码。

所以，经验法则是让事物只有在必要的时候才可见。从private开始，只在需要时添加更多的可见性。只公开用户必须知道的内容，公开的每一个细节都会限制您重新设计系统的能力。

如果您希望用户能够自定义行为，而不是将内部构件公开以便他们可以覆盖它们，那么将这些内部构件推到对象中并使该接口公开通常是一个更好的主意。这样他们就可以简单地插入一个新对象。例如，如果您正在编写一个CD播放器，并且希望"Go find information about this cd"位可自定义，而不是将这些方法公开，那么您可以将所有这些功能放到自己的对象中，只公开对象的getter/setter。通过这种方式，对暴露你的胆量小气会鼓励良好的组合和关注的分离。

就个人而言，我只坚持"私人"和"公开"。很多OO语言都有这个功能。""保护"可以很方便，但它确实是个骗局。一旦一个接口不仅仅是私有的，它就超出了你的控制范围，你必须去寻找其他人的代码来寻找用途。

这就是"出版"理念的由来。改变一个接口(重构它)需要你找到所有正在使用它的代码，并改变它。如果接口是私有的，那么没问题。如果它是受保护的，你必须找到你的所有子类。如果是公开的，你必须找到所有使用你的代码的代码。有时这是可能的，例如，如果您正在处理仅供内部使用的公司代码，那么接口是否是公共的并不重要。您可以从公司存储库中获取所有代码。但是，如果一个接口是"发布的"，如果有代码在您的控制之外使用它，那么您就是主机。您必须支持该接口或具有破坏风险的代码。即使是受保护的接口也可以被认为是已发布的(这就是为什么我不关心受保护的接口)。

许多语言发现公共/保护/私有的层次性太过局限，与现实不符。为此，有一个特质班的概念，但这是另一个节目。

相关讨论

这是一张更好的桌子。(未来验证，模块栏)
BR/>

Java Access Modifiers

解释

  • 私有成员(i只能在声明的同一类中访问。

  • 没有访问修饰符(j的成员)只能在同一包中的类中访问。

  • 受保护的成员(k可以在同一包中的所有类内以及在其他包中的子类内访问。

  • 所有类都可以访问公共成员(l(除非它驻留在不导出其声明的包的模块中)。

选择哪种修改器？

访问修饰符是一个帮助您防止意外破坏封装的工具(*)。问问你自己，你是否打算让成员成为类、包、类层次结构的内部成员，或者根本不是内部成员，然后相应地选择访问级别。

实例：

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

(*)封装到底是什么？

相关讨论

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
                | 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注释，以防止在重构时破坏内容。

相关讨论

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

"默认"访问(由缺少关键字指定)也称为包私有。异常：在接口中，没有修饰符表示公共访问；禁止非公共修饰符。枚举常量始终是公共的。

总结

是否允许使用此访问说明符访问成员？

  • 成员是private：仅当成员与调用代码在同一类中定义时。
  • 成员是包私有的：仅当调用代码位于成员的立即封闭包内时。
  • 成员是protected：同一个包，或者成员是在包含调用代码的类的超类中定义的。
  • 会员是public：是的。

哪些访问说明符适用于

局部变量和形参不能使用访问说明符。由于根据范围界定规则，它们本质上是外部无法访问的，因此它们实际上是私有的。

对于顶级范围的类，只允许使用public和package private。这种设计选择可能是因为protected和private在包级别上是多余的(没有包的继承)。

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

相关：Java类可访问性

秩序

访问说明符可以严格排序

public > protected > package-private > private

这意味着public提供的访问最多，private提供的访问最少。对私有成员的任何引用也对包私有成员有效；对包私有成员的任何引用对受保护成员有效，依此类推。(允许受保护成员访问同一包中的其他类被认为是错误的。)

笔记

  • 允许类的方法访问同一类的其他对象的私有成员。更确切地说，C类的方法可以访问C上任何子类对象的C的私有成员。(与使用private[this]支持它的scala相比。)
  • 您需要访问构造函数来构造对象。因此，如果所有构造函数都是私有的，则只能通过类内的代码(通常是静态工厂方法或静态变量初始值设定项)来构造类。同样，对于包私有或受保护的构造函数。
    • 只有私有构造函数还意味着类不能在外部进行子类化，因为Java需要子类的构造函数隐式或显式地调用超类构造函数。(但是，它可以包含一个嵌套类，该类是它的子类。)

内部类

您还必须考虑嵌套范围，例如内部类。复杂性的一个例子是内部类有成员，这些成员本身可以接受访问修饰符。因此，您可以拥有一个带有公共成员的私有内部类；该成员是否可以被访问？(见下文)一般规则是查看范围并递归地思考，看看您是否可以访问每个级别。

但是，这是相当复杂的，对于详细的细节，请参考Java语言规范。(是的，过去有编译器错误。)

要了解这些是如何交互的，请考虑这个例子。可以"泄漏"私有内部类；这通常是一个警告：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
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();
    }
}

编译器输出：

1
2
3
4
Test.java:4: secretMethod() in Example.NestedClass is defined in an inaccessible class or interface
        Example.leakPrivateClass().secretMethod(); // error
                                  ^
1 error

一些相关问题：

  • Java -方法内部可访问性包私有类？
相关讨论

根据经验：

  • private：类作用域。
  • default(或package-private)：包装范围。
  • protected：package scope + child(类似于包，但我们可以从不同包中对其进行子类化)。受保护的修饰符始终保持"父子"关系。
  • public：到处都是。

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

  • (d)直接(从同一类内的方法调用)。
  • (r)引用(使用对类的引用或通过"dot"语法调用方法)。
  • (i)nheriance(通过子类)。

然后我们有一个简单的表：

1
2
3
4
5
6
7
8
9
10
11
12
13
+—-———————————————+————————————+———————————+
|                 |    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。我们知道它类似于默认修饰符，但有一个例外，子类可以看到它。但是如何呢？下面是一个很有希望澄清这一困惑的例子：

  • 假设我们有两个类：Father和Son，每个类都有自己的包：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    package fatherpackage;

    public class Father
    {

    }

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

    package sonpackage;

    public class Son extends Father
    {

    }

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

    1
    2
    3
    4
    5
    6
    package fatherpackage;

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

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

  • 在同一个包中定义了foo()的类(fatherpackage中)内：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    package fatherpackage;

    public class SomeClass
    {
        public void someMethod(Father f, Son s)
        {
            f.foo();
            s.foo();
        }
    }

  • 在子类中，在当前实例上通过this或super执行以下操作：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    package sonpackage;

    public class Son extends Father
    {
        public void sonMethod()
        {
            this.foo();
            super.foo();
        }
    }

  • 在类型相同的引用上：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    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中]：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    package fatherpackage;

    public class Son extends Father
    {
        public void sonMethod(Father f)
        {
            f.foo();
        }
    }

  • 下列情况无效。

  • 对于类型为父类且在定义foo()的包(fatherpackage外)之外的引用：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    package sonpackage;

    public class Son extends Father
    {
        public void sonMethod(Father f)
        {
            f.foo(); // compilation error
        }
    }

  • 子类包中的非子类(子类从其父级继承受保护成员，并使其对非子类私有)：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    package sonpackage;

    public class SomeClass
    {
        public void someMethod(Son s) throws Exception
        {
            s.foo(); // compilation error
        }
    }
相关讨论

私人的

  • 方法、变量和构造函数

声明为私有的方法、变量和构造函数只能在声明的类本身内访问。

  • 类和接口

私有访问修饰符是最严格的访问级别。类和接口不能是私有的。

注释

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

受保护的

  • 类和接口

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

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

注释

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

公众

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

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

  • 不同的包

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

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

默认-无关键字：

默认访问修饰符意味着我们不显式声明类、字段、方法等的访问修饰符。

  • 在同一个包中

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

注释

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

相关答案

  • Java中重写静态方法

引用链接

http://docs.oracle.com/javase/tutorial/java/javaoo/accesscontrol.htmlhttp://www.tutorialspoint.com/java/java_access_modifiers.htm(http://www.tutorialspoint.com/java/java_access_modifiers.htm)

私人：仅限访问班级

默认(无修饰符)：对类和包的访问受限

受保护：对类、包和子类的访问受限(包内和包外)

public:可访问类、包(all)和子类…简而言之，无处不在。

区别可以在已经提供的链接中找到，但使用哪一个通常归结为"知识最少原则"。只允许所需的最小可见性。

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

public：基本上，无论是否在同一个包中，都可以从任何类访问。

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

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

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

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

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

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

在非静态方法中，由于这个引用(也在构造函数中)，您可以直接访问，但要在静态方法中访问，您需要创建类的对象。

Java中的访问修饰符。

Java访问修饰符用于在Java中提供访问控制。

1。违约：

只能访问同一包中的类。

例如，

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// 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。公众

可以从任何地方访问。(全局访问)

例如，

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// 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();
  }
}

Output:Hello

三。私人的

只能在同一类中访问。

如果试图访问另一个类中某个类的私有成员，则会引发编译错误。例如，

1
2
3
4
5
6
7
8
9
10
11
12
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。受保护的

只能访问同一包中的类和子类

例如，

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// 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();
  }
}

Output: Hello

Enter image description here

对包可见。默认值。不需要修改器。

仅对类可见(私有)。

对世界可见(公开)。

对包和所有子类可见(受保护)。

变量和方法可以声明为不带任何调用的修饰符。默认示例：

1
2
3
4
5
String name ="john";

public int age(){
    return age;
}

私有访问修饰符-私有：

声明为私有的方法、变量和构造函数只能在声明的类本身内访问。私有访问修饰符是最严格的访问级别。类和接口不能是私有的。

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

使用私有修饰符是对象封装自身并从外部隐藏数据的主要方式。

实例：

1
2
3
4
5
6
7
8
9
10
11
12
Public class Details{

    private String name;

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

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

公共访问修饰符-公共：

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

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

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

例子：

1
2
3
public void cal(){

}

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

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

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

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

1
2
3
4
5
6
7
8
9
10
11
12
class Van{

    protected boolean speed(){

    }
}

class Car{
    boolean speed(){
    }

}

  • 公共-可从应用程序中的任何位置访问。

  • 默认值-可从包访问。

  • 受保护-可从其他包中的包和子类访问。也

  • 私有-只能从类访问。

我只想说明一个非常常见的错误细节，包括本页大多数答案。"默认的"访问"(当不存在访问修饰符时)并不总是与包私有相同。这取决于事情是什么。

  • 默认情况下，非成员类型(即未在其他类型中声明的类、枚举、接口和注释类型)是包私有的。(JLS第64.1)

  • 默认情况下，类成员和构造函数是包私有的。(JLS第64.1)

  • 默认情况下，枚举构造函数是私有的。(实际上，枚举构造者必须是私有的，试图将其公开或保护是错误的)。枚举常量是公共的，不允许任何访问说明符。默认情况下，枚举的其他成员是包私有的。(JLS第8.9卷)

  • 默认情况下，接口和注释类型的所有成员都是公共的。(事实上，接口和注释类型的成员必须是公共的，试图将其私有或受保护是错误的。)(jls§9.3至9.5)

相关讨论

此页对受保护的默认访问修饰符写得很好

…protected：protected访问修饰符有点复杂，可以说是默认访问修饰符的超集。就同一包中的访问而言，受保护成员与默认成员相同。不同的是，受保护的成员也可以被声明成员的类的子类访问，这些子类在父类所在的包之外。

但这些受保护的成员"只能通过继承在包外部访问"。也就是说，您可以直接访问某个类的子类中的受保护成员，就像该成员存在于子类本身一样。但是，通过使用父类的引用，该受保护成员将无法在包外部的子类中访问。…

相关讨论

大卫的回答提供了每个访问修饰符的含义。至于何时使用每个类，我建议公开所有类和每个类的方法，这些类是用于外部使用的(它的API)，其他的都是私有的。

随着时间的推移，您将对何时使某些类包成为私有的以及何时声明某些受保护的方法以在子类中使用有意义。

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

这与Java访问修饰符有关。

从Java访问修饰符：

A Java access modifier specifies which classes can access a given
class and its fields, constructors and methods. Access modifiers can
be specified separately for a class, its constructors, fields and
methods. Java access modifiers are also sometimes referred to in daily
speech as Java access specifiers, but the correct name is Java access
modifiers. Classes, fields, constructors and methods can have one of
four different Java access modifiers:

  • List item
  • private
  • default (package)
  • protected
  • public

通过控制对类教程成员的访问：

Access level modifiers determine whether other classes can use a
particular field or invoke a particular method. There are two levels
of access control:

  • At the top level—public, or package-private (no explicit modifier).
  • At the member level—public, private, protected, or package-private (no explicit modifier).

A class may be declared with the modifier public, in which case that
class is visible to all classes everywhere. If a class has no modifier
(the default, also known as package-private), it is visible only
within its own package

The following table shows the access to members permitted by each
modifier.

1
2
3
4
5
6
7
8
╔═════════════╦═══════╦═════════╦══════════╦═══════╗
║ 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     ║
╚═════════════╩═══════╩═════════╩══════════╩═══════╝

The first data column indicates whether the class itself has access to
the member defined by the access level. As you can see, a class always
has access to its own members. The second column indicates whether
classes in the same package as the class (regardless of their
parentage) have access to the member. The third column indicates
whether subclasses of the class declared outside this package have
access to the member. The fourth column indicates whether all classes
have access to the member.

Access levels affect you in two ways. First, when you use classes that
come from another source, such as the classes in the Java platform,
access levels determine which members of those classes your own
classes can use. Second, when you write a class, you need to decide
what access level every member variable and every method in your class
should have.

相关讨论

public-protected-default和private是访问修饰符。

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

  • 类可以是公共的或默认的
  • 类成员可以是public、protected、default或private。

    • 在类外无法访问private默认值只能在包中访问。在包以及扩展包的任何类中受保护。公众是为所有人开放的。

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

    相关讨论

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

    假设你是一所大学的学生，你有一个朋友周末来看你。假设在校园中央有一座大学创始人的大雕像。

    • 当你把他带到校园时，你和你的朋友看到的第一件事就是这个雕像。这意味着，任何在校园里行走的人都可以在没有大学许可的情况下观看雕像。这使雕像成为公开的。

    • 接下来，你想带你的朋友去你的宿舍，但为此你需要把他登记为访客。这意味着他得到了一个通行证(和你的一样)，可以进入校园里的各种建筑。这将使他的访问卡受到保护。

    • 您的朋友想登录校园WiFi，但没有任何凭据。他唯一能上网的方法就是和他分享你的登录信息。(记住，每个上大学的学生都有这些登录证书)。这将使您的登录凭证没有修改器。

    • 最后，你的朋友想阅读你在网站上发布的学期进度报告。但是，每个学生都有自己的个人登录名来访问校园网站的这一部分。这将使这些凭据成为私有的。

    希望这有帮助！

    当您考虑访问修饰符时，只需这样考虑它(适用于变量和方法)：

    public->可从每个位置访问private->只能在声明它的同一类中访问

    现在，当涉及到default和protected时，就出现了混乱。

    default->不存在访问修饰符关键字。这意味着它严格地在类的包中可用。在这个包之外的任何地方都不能访问它。

    protected->比default稍微轻一些，除了同一个包类之外，它可以被声明包外的子类访问。

    这都是关于封装的(或者如JoePhillips所说，知识最少)。

    从最严格的(私有)开始，看看以后是否需要更少的限制性修饰符。

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

    例如：您可以将敏感的安全方法放入"安全"包中。然后放置一个公共类，该类访问此包中的一些安全相关代码，但保留其他安全类包的私有性。因此，其他开发人员只能使用这个包外部的公共可用类(除非他们更改了修饰符)。这不是安全功能，但将指导使用。

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

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

    相反，如果将所有内容设置为公共的，则不清楚应该或不应该访问什么内容，这可能会导致编写大量javadoc(它不会通过编译器强制执行任何内容…)。