提问



在Java中,有关何时使用每个访问修饰符的明确规则,即默认(包私有),publicprotectedprivate,同时使classinterface并处理继承?

最佳参考


官方教程可能对你有用。[70]


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

+ : accessible
blank : not accessible

其它参考1


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


私人



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


Package Private



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


受保护的



Package Private +可以通过子类或包成员看到。


公共



每个人都可以看到它。


公开



在我控制的代码外面可见。 (虽然不是Java语法,但对于这个讨论很重要。)[71]


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


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


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


如果您希望用户能够自定义行为,而不是将内部公开,以便他们可以覆盖它们,那么将这些内容推入对象并将该界面公开通常是一个更好的主意。这样他们就可以简单地插入例如,如果你正在编写一个CD播放器并想要查找有关此CD的信息位可自定义,而不是将这些方法公开,那么你将所有这些功能放入它自己的对象并使你的对象得到吸引力/setter public。以这种方式吝啬暴露你的胆量鼓励良好的成分和关注点的分离


就个人而言,我坚持只是私人和公共。许多OO语言就是这样。 受保护可以很方便,但它确实是一种欺骗。一旦界面不仅仅是私密的,它就超出了你的控制范围,你必须去寻找其他人的代码才能找到用途。


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


许多语言发现公共/受保护/私有的等级性质太过限制而不符合现实。为此,有一个特质类的概念,但这是另一个节目。[72]

其它参考2


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





[73]




说明




  • 私有成员仅可在与声明的同一个类中访问。

  • 具有无访问修饰符的成员只能在同一个包中的类中访问。

  • 受保护的成员可以在其他包中的子类中的同一个包和中的所有类中访问。

  • 所有类都可以访问 public 成员(除非它位于不导出声明的包的模块中)。[74]






选择哪种修改器?



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


实施例



  • 字段long internalCounter应该是私有的,因为它是可变的和实现细节。

  • 只应在工厂类(在同一个包中)实例化的类应该有一个包受限制的构造函数,因为它不应该直接从包外部调用它。

  • 应该保护在呈现之前调用并在子类中用作钩子的内部void beforeRender()方法。

  • 从GUI代码调用的void saveGame(File dst)方法应该是公共的。



(*)什么是封装?

其它参考3


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

其它参考4


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


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


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


此外,在重写时使用@Override注释可以防止重构时出现问题。

其它参考5


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


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


摘要



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



  • 成员是private:仅当成员与调用代码在同一个类中定义。

  • 成员是包私有:仅当调用代码位于成员s立即封装包。

  • 成员是protected:相同的包,或者如果成员是在包含调用代码的类的超类中定义的。

  • 会员是public:是的。



哪些访问说明符适用于



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


对于顶级作用域中的类,仅允许public和package-private。这种设计选择大概是因为protectedprivate在包级别上是多余的(没有包的继承)。


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


相关:Java类可访问性


顺序



访问说明符可以严格排序



  public> protected> package-private> private



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


备注




  • 允许类的方法 访问同一类的其他对象的私有成员。更确切地说,类C的方法可以访问C的任何子类的对象上的C的私有成员Java并不支持通过实例限制访问,只能通过类来限制访问。 (与使用private[this]支持它的Scala相比。)

  • 您需要访问构造函数才能构造对象。因此,如果所有构造函数都是私有的,则该类只能由生活在类中的代码构造(通常是静态工厂方法或静态变量初始化器)。类似地,对于包私有或受保护的构造函数。


    • 只有私有构造函数也意味着该类不能在外部进行子类化,因为Java要求子类的构造函数隐式或显式地调用超类构造函数。(但是,它可以包含一个嵌套类,它将其子类化。)




内部课程



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


但是,这非常复杂,有关详细信息,请参阅Java语言规范。 (是的,过去有过编译器错误。)[79]


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


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 - package-private class中的方法可访问性?


其它参考6


根据经验:



  • 私有:类范围。

  • 默认(或 package-private ):包范围。

  • 受保护:包范围 + child (与包类似,但我们可以从不同的包中对其进行子类化)。 protected修饰符始终保持父子关系。

  • 公开:无处不在。



因此,如果我们将访问权限分为三个权限:



  • (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   |
+—————————————————+————————————+———————————+

其它参考7


很短的



  • public:无处不在。

  • protected:可以通过相同包的类和驻留在任何包中的子类访问。

  • 默认(未指定修饰符):可由同一包的类访问。

  • private:只能在同一个班级内访问。


其它参考8


Java中最容易被误解的访问修饰符是protected。我们知道它类似于默认修饰符,但有一个例外,其中子类可以看到它。但是如何?这是一个有希望澄清混淆的例子:



  • 假设我们有2个班级; FatherSon,每个都在自己的包中:


    package fatherpackage;
    
    public class Father
    {
    
    }
    
    -------------------------------------------
    
    package sonpackage;
    
    public class Son extends Father
    {
    
    }
    

  • 让我们添加一个受保护的方法foo()Father


    package fatherpackage;
    
    public class Father
    {
        protected void foo(){}
    }
    

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



    1. 位于定义foo()的同一包中的类(fatherpackage)内:


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

    2. 在子类中,通过thissuper在当前实例上:


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

    3. 在类型相同的引用上:


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

    4. 在类型为父类的引用上,在里面定义foo()的包fatherpackage)[[这可以包含在上下文中。 1]]:


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


  • 以下情况无效。



    1. 在类型为父类的引用上,在外定义foo()的包(fatherpackage):


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

    2. 子类包内的非子类(子类从其父类继承受保护的成员,并使它们对非子类是私有的):


      package sonpackage;
      
      public class SomeClass
      {
          public void someMethod(Son s) throws Exception
          {
              s.foo(); // compilation error
          }
      }
      



其它参考9


私人




  • 方法,变量和构造函数



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



  • 类和接口



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


注意


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




受保护的




  • 类和接口



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


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


注意


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






公开



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


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



  • 不同的套餐



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


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






默认-No关键字:



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



  • 在相同的包中



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


注意


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


相关答案




  • 覆盖java中的静态方法



参考链接



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

其它参考10


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

其它参考11


私有:仅限课程访问权限


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


受保护:对类,包和子类(包内和包外)的有限访问权限


公开:可访问类,包(所有)和子类......简而言之,无处不在。

其它参考12


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



  输出:你好



[84]

其它参考13


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


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


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


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


要访问,您可以创建该类的对象。但是您无法在包外部访问此变量。


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


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


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


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

其它参考14


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


仅对班级可见(私人)。


对世界可见(公众)。


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


可以在不调用任何修饰符的情况下声明变量和方法。默认示例:


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的类,方法,构造函数,接口等。因此,可以从属于Java Universe的任何类访问在公共类中声明的字段,方法,块。


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


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


例:


public void cal(){

}


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


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


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


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


class Van{

    protected boolean speed(){

    }
}

class Car{
    boolean speed(){
    }

}

其它参考15


这个页面很好地描述了受保护的&默认访问修饰符[85]


....
受保护:受保护的访问修饰符有点棘手,您可以说是默认访问修饰符的超集。受保护的成员与t相同就默认成员而言,就同一个包中的访问而言。不同之处在于,受保护成员也可以被声明成员的类的子类访问,这些成员位于父类所在的包之外。


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

其它参考16


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



  • 默认情况下,非成员类型(即未在其他类型中声明的类,枚举,接口和注释类型)是package-private。 (JLS§6.6.1)[86]

  • 默认情况下,类成员和构造函数是包私有的。 (JLS§6.6.1)[87]

  • 默认情况下,枚举构造函数私有。 (实际上,枚举结构必须是私有的,尝试将它们公开或受保护是错误的)。枚举常量是公共的,不允许任何访问说明符。枚举的其他成员默认为package-private。 (JLS§8.9)[88]

  • 界面和注释类型的所有成员默认为公开。 (实际上,接口和注释类型的成员必须是公开的,尝试将它们设为私有或受保护是错误的。)(JLS§9.3至9.5)[89]


其它参考17



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

  • 默认 - 可从包中访问。

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

  • 私有 - 只能从其班级访问。


其它参考18


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


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

其它参考19



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

  • 仅对班级可见; 私人

  • 向世界展示; 公开

  • 包和所有子类可见; 受保护



所以让我们谈谈访问控制和继承
继承方法的以下规则是:



  • 在超类中声明public的方法也必须是公开的
       子类。

  • 在超类中声明protected的方法必须是protected
    public在子类中;他们不能私下。

  • 声明没有访问控制的方法(没有使用修饰符)可以
    在子类中声明更私有。

  • 声明private的方法根本不是遗传的,所以没有
    对他们的统治。


其它参考20


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


这与Java Access Modifiers有关。[90]


来自Java Access Modifiers:[91]



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

  
  

      
  • 列表项

  •   
  • 私有

  •   
  • 默认(包)

  •   
  • 保护

  •   
  • 公共

  •   



从控制对类成员的访问教程:[92]



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

  
  

      
  • 在顶层 - 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平台中的类,
  访问级别确定您自己的那些类的成员
  课程可以使用。其次,当你写一堂课时,你需要做出决定
  每个成员变量和类中的每个方法的访问级别
  应该有。


其它参考21


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


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



  1. 班级可以是公开的或默认的

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



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


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

其它参考22


很多时候我已经意识到,通过创建真实世界的类比,记住任何语言的基本概念都是可能的。这是我在Java中理解访问修饰符的类比:


让我们假设你是一个大学的学生,你有一个朋友周末来看你。假设校园中间有一个大学的创始人的大雕像。



  • 当你把他带到校园时,你和你朋友看到的第一件事就是这座雕像。这意味着任何走进校园的人都可以在未经大学许可的情况下观看雕像。这使雕像成为 PUBLIC

  • 接下来,您想带上您的朋友到您的宿舍,但为此您需要将他注册为访客。这意味着他获得了进入通行证(与您的通行证相同)以进入校园内的各种建筑物。这会使他的访问卡成为 PROTECTED

  • 您的朋友想要登录校园WiFi,但没有任何凭据可以这样做。他可以上网的唯一方法就是与他分享您的登录信息。(请记住,每个上大学的学生还拥有这些登录凭据)。这将使您的登录凭据为 NO MODIFIER

  • 最后,您的朋友想要阅读您在网站上发布的学期的进度报告。但是,每个学生都有自己的个人登录信息,可以访问校园网站的这一部分。这会将这些凭据设为 PRIVATE



希望这可以帮助!

其它参考23


当您考虑访问修饰符时,只需以这种方式考虑它(适用于变量方法):


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


现在,当defaultprotected出现混乱时


default - >不存在访问修饰符关键字。这意味着它可以严格地在类的包中使用。 无处在该包之外可以访问它。


protected - >稍微不如default严格,除了相同的包类,它可以被包之外的子类访问,它被声明。

其它参考24


这完全是关于封装(或正如Joe Phillips所说,最少知识)。


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


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


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


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


另一个问题是,彼此依赖很多的类可能最终存在于同一个包中,如果依赖性太强,最终可能会被重构或合并。


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