Kata Kunci Dilindungi dalam Java

Kata kunci yang dilindungi ialah kata kunci yang digunakan untuk mengehadkan skop pembolehubah, kaedah dan pembina boleh diakses. Ia adalah salah satu jenis pengubah suai akses di Java. Ia digunakan untuk membezakan antara skop kaedah, pembolehubah, pembina, dan kelas. Terdapat 4 jenis pengubah suai akses di Java, dan ia adalah:

1. Kata kunci lalai: Kata kunci itu boleh diakses hanya dalam pakej dan tidak boleh dipanggil di luarnya. Seperti namanya, ia ditetapkan secara automatik sebagai lalai apabila tiada penentu akses disebut.
2. Kata kunci awam: Kata kunci tersebut boleh diakses dari mana-mana sahaja dalam program. Ini bermakna ia boleh digunakan dari kelas yang sama atau berbeza dan pakej yang sama atau berbeza.
3. Kata kunci peribadi: Mereka mengehadkan kata kunci ke tahap yang lebih tinggi dengan tidak membenarkan kata kunci itu diakses dari mana-mana sahaja di luar kelas itu sendiri.
4. Kata kunci yang dilindungi: Dalam artikel ini, kita akan mengetahui lebih lanjut tentang kata kunci yang dilindungi.

Setelah pembolehubah atau kaedah ditandakan sebagai dilindungi, ia hanya boleh diakses melalui kaedah di bawah:

• Di dalam kelas yang sama di mana ia diisytiharkan.
• Dari kelas lain yang juga dalam pakej yang sama dengan kelas yang diisytiharkan.
• Kelas yang diwarisi daripada kelas yang diisytiharkan, tanpa mengira pakejnya.

Kata kunci yang dilindungi adalah seperti gabungan kedua-dua kata kunci awam dan peribadi sejak ia diperkenalkan untuk mengakses pembolehubah di luar kelas (yang tidak mungkin dalam kes kata kunci peribadi) dan mengekalkan bahawa hanya kaedah tertentu boleh mewarisi yang sama.

Sintaks

Kata kunci yang dilindungi diisytiharkan dengan kata kunci yang didahulukan padanya sebagai "dilindungi". Kami mula-mula mengisytiharkan kata kunci yang dilindungi dalam salah satu kelas yang dipanggil "MyClass" seperti di bawah:

class MyClass {
protected String name = "Katy";
protected int token= 55;
}
public class SubClass extends MyClass {
public static void main(String[] args) {
SubClass obj = new SubClass();
System.out.println(obj.name + "'s token number is: " + obj.token);
}
}

Di sini kelas "SubClass" memanjangkan "MyClass", dan oleh itu kata kunci yang dilindungi boleh digunakan di sini dengan mencipta objek SubClass dan dengan memanggil pembolehubah.

Output:

Kata kunci yang dilindungi hanya boleh digunakan pada peringkat ahli, iaitu kelas dalaman yang diisytiharkan di luar fungsi dan bukan statik. Kata kunci yang dilindungi adalah berbeza daripada kata kunci peribadi kerana kata kunci tersebut boleh diakses di luar kelas dan dalam subkelas pakej lain.

Beberapa sekatan untuk menggunakan kata kunci yang dilindungi ialah:

• Ia tidak boleh digunakan untuk mengisytiharkan kelas sebagai dilindungi.
• Antara muka tidak boleh diisytiharkan sebagai dilindungi.
• Kebolehcapaian di luar pakej hanya melalui pewarisan.
• Pembina yang dibuat dilindungi tidak boleh diakses di luar pakej dengan mencipta contohnya.

Contoh Kata Kunci Dilindungi dalam Java

Mari kita lihat beberapa contoh di mana kita boleh memahami konsep kata kunci yang dilindungi dengan lebih baik.

1. Memanggil kata kunci yang dilindungi tanpa melanjutkan kelas induk

Di sini kami cuba memanggil kata kunci daripada kelas induk "pakej1". "ProtectedExample2" dicipta dalam "package2", dan kata kunci "disp" dipanggil di sini. Tetapi kod itu tidak akan dapat mengakses kata kunci kerana kelas anak tidak mewarisi nilainya daripada kelas utama dan akan membuang pengecualian seperti yang ditunjukkan.

Kod:

package com.package1;
public class Example {
protected String disp="Printing message from protected variable from package1";
}
//Create new package as com.package2
//Create new class as ProtectedExample2
package com.package2;
import com.package1.Example;
public class ProtectedExample2 {
public static void main(String[] args) {
ProtectedExample2 a=new ProtectedExample2();
System.out.println(a.disp);
}
}

Output:

2. Mengakses kelas yang dilindungi

Dalam contoh ini, kami cuba mengakses kelas "ProtectedExample5", yang dilindungi. Ini menyebabkan ralat kompilasi.

Kod:

protected class ProtectedExample5 {
void display()
{
System.out.println("Try to access outer protected class");
}
public static void main(String[] args) {
ProtectedExample5 p=new ProtectedExample5();
p.display();
}
}

Output:

3. Memaparkan kata kunci yang dilindungi daripada pakej yang sama tetapi kelas yang berbeza

Dalam contoh di bawah, kami mula-mula mencipta pakej yang dipanggil "com.package1" dan mencipta kelas baharu dengan nama "Contoh". Di sini kami mengisytiharkan kata kunci "disp" kami dilindungi. Kami akan cuba memaparkan kata kunci yang dilindungi ini menggunakan kelas "Contoh1". Untuk ini, pertama sekali, objek kelas induk "Contoh1" perlu dibuat dan kemudian mencetak nilai yang diberikan kepada kata kunci "disp".

Kod:

package com.package1;
public class Example {
protected String disp="Printing message from protected variable from package1";
}
class Example1 {
public static void main(String[] args) {
Example obj=new Example();
System.out.println(obj.disp);
}
}

Output:

4. Displaying protected keyword from a different package

Using the same code as above, we shall see how to call the protected keyword by creating a different package, “package2”. A protected keyword can be accessed only through inheritance from package1; hence “ProtectedExample2” is extended from “Example”. In a similar way as the first example, we have to create an object of the class “ProtectedExample2” in order to access the protected keyword from package “com.package1”.

Code:

package com.package2;
import com.package1.Example;
public class ProtectedExample2 extends Example{
public static void main(String[] args) {
ProtectedExample2 a=new ProtectedExample2();
System.out.println(a.disp);
}
}

Output:

5. Accessing a protected class by overriding to sub-class

Here the class is declared as protected inside the inherited class “Example5”. Also, a protected class called “Example” is declared outside the function but in the same package. When an object of “Example5” is created and the protected class “disp()” is called, we can observe that the overridden method is called instead of the outside class. This is because we shall not be able to import “com.package1” and its class “Example” since it is not visible and causes a compilation error.

Code:

//Create a file by Example.java
package com.package1;
class Example
{
protected void disp()
{
System.out.println("Printing from protected class in the outside function");
}
}
//Create a class by the name Example5.java
public class Example5 extends Example {
protected void disp()
{
System.out.println("Accessing the overriden function");
}
public static void main(String[] args) {
Example5 exp=new Example5();
exp.disp();
}
}

Output:

Importance of Protected Keyword

The importance of protected keyword in java is:

• These keywords allow the classes or their variables to be inherited from their parent class which is not possible with any other restricted keyword such as private.
• A protected keyword is the combination of a private keyword’s advantage and that of a public keyword. It eliminates the disadvantage of public keyword that the variable or class be accessible from anywhere in the program by restricting the scope.

Conclusion

As shown in the above examples, we choose protected keywords depending on the access level we require at the code level. They help greatly in cases where the same variable or class needs to be accessed from other inherited methods in the program. A parent-child relationship is always present between the parent class and its sub-classes which are using the protected keyword.

Atas ialah kandungan terperinci Kata Kunci Dilindungi dalam Java. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!