Java中受保护的关键字与示例

Java中的访问修饰符有助于限制类、构造函数、变量、方法或数据成员的范围。 Java中有四种类型的访问修饰符可用。各种修饰符的访问方式如下表所示：

Java中的protected 关键字指的是它的访问修饰符之一。声明为受保护的方法或数据成员可以从

• 同一班内。
• 相同包的子类。
• 同一个包的不同类。
• 不同包的子类。

有一些重要的点需要记住如下：

1. 如果希望访问包外的受保护修饰符，则继承 需要申请。
2. 保护构造函数可防止用户在包外创建类的实例。
3. 在覆盖期间，当变量或方法受到保护时，可以仅使用 public 或 protected 修饰符将其覆盖到其他子类。
4. 无法保护外部类和接口。

实现：这里我们将创建两个包 p1 和 p2。 p1 中的 A 类是公开的，以便在 p2 中访问它。类 A 中显示的方法是受保护的，类 B 是从类 A 继承的，然后通过创建类 B 的对象来访问此受保护的方法。

示例 1：包 p1

Java

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

 
包 p2

Java

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

输出：

GeeksforGeeks

Now let us try to analyze different conditions of access: 

1. Calling protected function without extending the parent class
2. Accessing a protected class
3. Accessing display function from the same package but different 
4. Accessing display function from a different package
5. Accessing a protected class by overriding to sub-class within the same package

A.在不扩展父类的情况下调用受保护的函数

在这里，我们将创建两个包 p1 和 p2。 p1 中的 A 类是公开的，以便在 p2 中访问它。 A 类中显示的方法是受保护的。但是代码将无法访问函数“display”，因为子类没有从主类继承它的值，并且会抛出一个异常，如图所示。

示例 1-A：包 p1

Java

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

示例 1-B：包 p2

Java

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

输出：

Exception in thread "main" 
java.lang.RuntimeException: 
Uncompilable source code - 
Erroneous sym type: p2.B.display
    at p2.B.main(B.java:16)

B：访问受保护的类

在这里，我们试图访问受保护的类 A 导致错误。

示例 A：

Java

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

示例 B：包 p2

Java

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

输出：这将引发错误

Exception in thread "main" 
java.lang.RuntimeException: 
Uncompilable source code - 
Erroneous sym type: p2.B.display
    at p2.B.main(B.java:16)

C: 从同一个包不同类访问显示函数

实现：在这个例子中，我们可以访问来自同一个包但不同类的受保护函数“display”

示例 A：包 p1

Java

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

示例 B： C 类

Java

// Java program to illustrate
// protected modifier
  
// Class C is a subclass of A
public class C {
    public static void main(String args[])
    {
        A obj = new A();
        obj.display();
    }
}

输出：

GeeksforGeeks

D：从不同的包访问显示函数

在这里，我们尝试通过继承和扩展类从不同的包中访问受保护的函数显示。

示例 A：包 p1

Java

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

示例 B：包 p2

Java

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

输出：

GeeksforGeeks

E：通过覆盖同一包中的子类来访问受保护的类

这里我们设计了两个类 A 和 C，其中类 C 是被覆盖的类。

示例 A： A 类

Java

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

示例 B： C 类

Java

// Java program to illustrate
// protected modifier
  
public class C extends A {
  
    // overridden function
    protected void display()
    {
        System.out.println("Class C");
    }
    public static void main(String args[])
    {
        C obj1 = new C();
        obj1.display();
    }
}

输出：

Class C