Java中的访问修饰符-yiteyi-C++库

顾名思义，Java中的访问修饰符有助于限制类、构造函数、变量、方法或数据成员的范围。java中有四种类型的访问修饰符：

null

默认值–不需要关键字
私有的
受保护的
平民的

access-modifiers-in-java

违约：如果没有为类、方法或数据成员指定访问修饰符，则称其具有违约默认情况下访问修改器。
- 未使用任何访问修饰符（即具有默认访问修饰符）声明的数据成员、类或方法是可访问的 只在同一包装内 .

在本例中，我们将创建两个包，包中的类将具有默认的访问修饰符，我们将尝试从一个包中访问第二个包中的类。

JAVA

                         // Java program to illustrate default modifier                       
                         package                                     p1;                       
                                   
                         // Class Geeks is having Default access modifier                       
                         class                                     Geek                       
                         {                       
                                                 void                                     display()                       
                                                 {                       
                                                 System.out.println(                                     "Hello World!"                                     );                       
                                                 }                       
                         }                       

JAVA

                         // Java program to illustrate error while                       
                         // using class from different package with                       
                         // default modifier                       
                         package                                     p2;                       
                         import                                     p1.*;                       
                                   
                         // This class is having default access modifier                       
                         class                                     GeekNew                       
                         {                       
                                                 public                                     static                                     void                                     main(String args[])                       
                                                 {                       
                                                 // Accessing class Geek from package p1                       
                                                 Geeks obj =                                     new                                     Geek();                       
                                   
                                                 obj.display();                       
                                                 }                       
                         }                       

输出：

Compile time error

私有的 ：使用关键字指定专用访问修饰符 私有的 .
- 声明为私有的方法或数据成员只能访问 在课堂上 它们在其中声明。
- 还有别的吗阶级这个 同一个包将无法访问 这些成员。
- 顶级类或接口不能声明为私有，因为
  1. private表示“仅在封闭类中可见”。
  2. protected是指“仅在封闭类和任何子类中可见”

因此，就类的应用而言，这些修饰符只适用于嵌套类，而不适用于顶级类

在本例中，我们将在同一个包p1中创建两个类A和B。我们将类a中的一个方法声明为private，并尝试从类B访问该方法，然后查看结果。

JAVA

                         // Java program to illustrate error while                       
                         // using class from different package with                       
                         // private modifier                       
                         package                                     p1;                       
                                   
                         class                                     A                       
                         {                       
                         private                                     void                                     display()                       
                                                 {                       
                                                 System.out.println(                                     "GeeksforGeeks"                                     );                       
                                                 }                       
                         }                       
                                   
                         class                                     B                       
                         {                       
                         public                                     static                                     void                                     main(String args[])                       
                                                 {                       
                                                 A obj =                                     new                                     A();                       
                                                 // Trying to access private method                       
                                                 // of another class                       
                                                 obj.display();                       
                                                 }                       
                         }                       

输出：

error: display() has private access in A
        obj.display();

受保护的 ：使用关键字指定受保护的访问修饰符 受保护的 .
- 声明为受保护的方法或数据成员是 可在同一个包或不同包中的子类中访问。

在本例中，我们将创建两个包p1和p2。p1中的A类已公开，以便在p2中访问。类A中显示的方法受保护，类B继承自类A，然后通过创建类B的对象来访问此受保护的方法。

JAVA

                         // Java program to illustrate                       
                         // protected modifier                       
                         package                                     p1;                       
                                   
                         // Class A                       
                         public                                     class                                     A                       
                         {                       
                         protected                                     void                                     display()                       
                                                 {                       
                                                 System.out.println(                                     "GeeksforGeeks"                                     );                       
                                                 }                       
                         }                       

JAVA

                         // Java program to illustrate                       
                         // protected modifier                       
                         package                                     p2;                       
                         import                                     p1.*;                                     // importing all classes in package p1                       
                                   
                         // Class B is subclass of A                       
                         class                                     B                                     extends                                     A                       
                         {                       
                         public                                     static                                     void                                     main(String args[])                       
                         {                       
                                                 B obj =                                     new                                     B();                       
                                                 obj.display();                       
                         }                       
                                   
                         }                       

输出：

GeeksforGeeks

平民的 ：使用关键字指定公共访问修饰符 平民的 .
- 公共访问修饰符具有 范围最广 在所有其他访问修饰符中。
- 声明为公共的类、方法或数据成员是 随处可见 在节目中。公共数据成员的范围没有限制。

JAVA

                           // Java program to illustrate                         
                           // public modifier                         
                           package                                        p1;                         
                           public                                        class                                        A                         
                           {                         
                           public                                        void                                        display()                         
                                                     {                         
                                                     System.out.println(                                        "GeeksforGeeks"                                        );                         
                                                     }                         
                           }                         

JAVA

                           package                                        p2;                         
                           import                                        p1.*;                         
                           class                                        B {                         
                                                     public                                        static                                        void                                        main(String args[])                         
                                                     {                         
                                                     A obj =                                        new                                        A;                         
                                                     obj.display();                         
                                                     }                         
                           }                         