Privat in Java

Das Schlüsselwort „private“ wird in Java verwendet, um die Einschränkung der Zugänglichkeit der Klasse, Methode oder einer Variablen im Java-Codeblock festzulegen. Wenn eine Klasse, Methode oder Variable im Programm als privat gekennzeichnet ist, bedeutet dies, dass auf eine bestimmte Klasse, Methode oder Variable im Gegensatz zur öffentlichen Methode nicht von außerhalb der Klasse oder Methode zugegriffen werden kann. Das Schlüsselwort Private wird normalerweise in Java in einer vollständig gekapselten Klasse verwendet.

Wie funktioniert ein privates Schlüsselwort in Java?

Privates Schlüsselwort in Java funktioniert innerhalb einer bestimmten Klasse. Es kann nicht außerhalb der Klasse darauf zugegriffen werden. Es funktioniert nicht außerhalb der Klasse/Klassen und der Schnittstelle/Schnittstellen. Private Keyword funktioniert gut, wenn die Mitglieder der Klasse PRIVATE sind, und das auch in einer vollständig gekapselten Klasse. Private Schlüsselwörter, Variablen oder Methoden können mithilfe einiger Zugriffsmodifikatoren auch für die Unterklasse/-klassen überschrieben werden, um PRIVATE METHOD außerhalb der Klasse aufzurufen. Damit funktioniert Private Keyword auch außerhalb der Klasse nur unter Verwendung der Private Access Modifiers.

Starten Sie Ihren kostenlosen Softwareentwicklungskurs

Webentwicklung, Programmiersprachen, Softwaretests und andere

Beispiele

Hier sind einige Beispiele für private Modifikatoren, die wie folgt lauten:

Beispiel #1

Hier veranschaulichen wir das Beispiel des Private Access Modifier, der einen Kompilierungsfehler aufgrund des Zugriffs auf private Datenmember aus der Klasse AB zeigt, was im folgenden Beispiel gezeigt wird. Auf private Methoden oder private Mitglieder kann nur innerhalb einer bestimmten Klasse zugegriffen werden.

Code:

class AB{
private double number = 100;
private int squares(int a){
return a*a;
}
}
public class Main{
public static void main(String args[]){
AB obj = new AB();
System.out.println(obj.number);
System.out.println(obj.squares(10));
}
}

Ausgabe:

Beispiel #2

Dies ist ein Beispiel zur Veranschaulichung der Verwendung des Schlüsselworts PRIVATE mit dem folgenden Programm:

Code:

class Emp{
private int id1;
private String name14;
private int age14;
public int getId1() {
return id1;
}
public void setId(int id1) {
this.id1 = id1;
}
public String getName14() {
return name14;
}
public void setName14(String name14) {
this.name14 = name14;
}
public int getAge14() {
return age14;
}
public void setAge14(int age14) {
this.age14 = age14;
}
}
public class Main{
public static void main(String args[]){
Emp e=new Emp();
e.setId(1473);
e.setName14("Pavan Kumar Sake");
e.setAge14(24);
System.out.println(e.getId1()+" "+e.getName14()+" "+e.getAge14());
}
}

Ausgabe:

Beispiel #3

Hier in diesem Beispiel können Sie sehen, wie die PRIVATE METHOD mithilfe des Zugriffsmodifikators, der die Standardeinstellung ist, auf die Unterklasse überschrieben wird. Es ist uns nicht einmal gestattet, die Methode/Methoden der übergeordneten Klasse aus der Unterklasse aufzurufen.

Code:

class ABC{
private void msg()
{
System.out.println("Hey Buddy this is the parent class method"); //Output of the Private Method
}
}
public class Main extends ABC{ // Private method is overridden using the access modifier
void msg()
{
System.out.println("Buddy this is the child class method");
}
public static void main(String args[]){
Main obj=new Main();
obj.msg();
}
}

Ausgabe:

Beispiel #4

Hier in diesem Beispiel veranschauliche ich, dass die PRIVATE-METHODE nicht außerhalb der Klasse aufgerufen/aufgerufen werden kann. Hier ruft nun die private Methode die Outside-Klasse auf, indem sie das Laufzeitverhalten der Klasse ändert.

Code:

import java.lang.reflect.Method;
class ABC {
private void display()
{
System.out.println("Hey Now private method is invoked/Called");
}
}
public class Main{
public static void main(String[] args)throws Exception{
Class d = Class.forName("ABC");
Object p= d.newInstance();
Method n =d.getDeclaredMethod("display", null);
n.setAccessible(true);
n.invoke(p, null);
}
}

Ausgabe:

Beispiel #5

Dies ist ein Beispiel für eine private Methode und ein privates Feld in der Programmiersprache Java. Hier verwenden private Methoden/Methoden zur Kompilierungszeit eine statische Bindung, die nicht einmal überschrieben werden kann. Nicht mit der Ausgabe der privaten Variable verwechseln, da auf die private Variable tatsächlich innerhalb der inneren Klasse(n) zugegriffen werden kann. Wenn PRIVATE-Variablen außerhalb der Klasse aufgerufen/aufgerufen werden, erzeugt der Compiler auf jeden Fall einen Fehler.

Code:

public class Main {
private String i_m_private1 = " \n Hey Buddy I am a private member and i am not even accessible outside of this Class";
private void privateMethod1() {
System.out.println("Outer Class Private Method");
}
public static void main(String args[]) {
Main outerClass = new Main();
NestedClass nestc = outerClass.new NestedClass();
nestc.showPrivate(); //This syntax shows private method/methods are accessible inside the class/inner class.
outerClass = nestc;
nestc.privateMethod1(); //It don't call/invoke private method from the inner class because
// you can not override the private method inside the inner class.
}
class NestedClass extends Main {
public void showPrivate() {
System.out.println("Now we are going to access Outer Class Private Method: " + i_m_private1);
privateMethod1();
}
private void privateMethod1() {
System.out.println("Nested Class's Private Method");
}
}
}

Ausgabe:

Vorteile

Im Folgenden erläutern wir die Vorteile der Verwendung privater Methoden/Felder in Java.

• Es kann auch auf Methoden, Felder und innere Klassen in der Programmiersprache Java angewendet werden.
• Wir können der äußeren Schnittstelle oder Klasse kein Private zuweisen.
• In der Java-Programmiersprache können die Klassen der obersten Ebene nicht immer privat sein.
• Natürlich wissen wir, dass auf private Variablen oder private Methoden nicht außerhalb der Java-Klasse zugegriffen werden kann, aber sie können auf andere Weise über eine Reflektion mithilfe von setAccessible(true) und durch Ändern der PRIVATE-Sichtbarkeit dort zugänglich sein.
• In der Java-Programmiersprache können diese Methoden nicht überschrieben werden, auch nicht innerhalb der inneren Klassen.
• PRIVATE-Mitglieder ermöglichen Java Virtual Machine und Compiler, es für eine bessere Leistung zu optimieren.

Regeln und Vorschriften für private Konstrukteure in Java

Hier sind einige Regeln und Vorschriften für Privatpersonen, die Sie kennen sollten.

• Wenn die Klasse PRIVATE CONSTRUCTOR enthält, können Sie kein Objekt dieser bestimmten Klasse aus der externen Klasse erstellen.
• Sie sollten außerhalb der Klasse nicht auf ein privates Schlüsselwort zugreifen. Wenn Sie es versuchen, wird ein Kompilierungsfehler für diese Urkunde erzeugt. Dazu müssen Sie den Code ändern.
• Klassen der obersten Ebene können in dieser Java-Sprache nicht privat sein.

Fazit

Am Ende des Hauptthemas sind wir froh zu erfahren, wie hilfreich und einfach die Verwendung von Private Keywords in Java ist. Ich hoffe, dass Sie in diesem Artikel das private Schlüsselwort, die private Variable, den Zugriffsmodifikator und den privaten Konstruktor verstehen und wissen, wie Sie diese privaten Schlüsselwörter in Programmen verwenden.

Das obige ist der detaillierte Inhalt vonPrivat in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!