Einführung in die Kapselung in Java
Die Kapselung ist eines der vier grundlegenden objektorientierten Programmierkonzepte in Java. Die Hauptidee dahinter ist das Verbergen von Implementierungsdetails vor Benutzern. Mit anderen Worten, Encapsulation ist das Zusammenfassen von Daten zu einer einzigen Einheit, um den Zugriff von außen zu verhindern. Da die Daten vor den anderen Klassen verborgen sind, wird dieser Vorgang auch als Verstecken von Daten bezeichnet. Betrachten wir als Beispiel die Arbeitsweise einer Glühbirne. Wir wissen nicht, was hinter der Glühbirne steckt, auch wenn wir sie benutzen. Bei der Java-Kapselung ist es jedoch möglich, mithilfe von Modifikatoren auf die Daten zuzugreifen. Schauen wir uns das im nächsten Abschnitt an.
Wie funktioniert Encapsulation in Java?
Die Kapselung funktioniert in Java von
- Deklarieren der Attribute oder Variablen in der Klasse als privat
Zum Beispiel erstellen wir eine Klasse Employee. Die Variablen müssen wie unten gezeigt als privat festgelegt werden.
private String EmpName;
private int EmpID;
private int EmpSal;
- Erstellen öffentlicher Methoden in der Klasse, um die Attribute oder Variablen abzurufen und festzulegen.
Es folgen die Methoden get und set für die verschiedenen privaten Variablen in der Klasse Employee.
Code:
public int getEmpSal()
(
return EmpSal;
)public String getEmpName()
(
return EmpName;
)
public int getEmpID()
(
return EmpID;
)
public void setEmpSal( int EmpSal)
(
this.EmpSal = EmpSal;
)
public void setEmpName(String EmpName)
(
this.EmpName = EmpName;
)
public void setEmpID( int EmpID)
(
this.EmpID = EmpID;
)
Mit diesen Methoden ist es möglich, die Klasse schreibgeschützt oder schreibgeschützt zu machen, dh wir können diese Methoden bei Bedarf überspringen.
Im Folgenden sind einige der Vorteile der Verkapselung aufgeführt.
- Einfachheit in der Anwendung
- Möglichkeit zur Wiederverwendung oder Änderung des Codes basierend auf den Anforderungen
- Schränkt die Zugänglichkeit von Daten ein
- Einfaches Testen von Einheiten, da der Code gekapselt ist
Java Bean Class ist eines der Beispiele für die vollständig gekapselte Klasse, da alle Datenelemente in der Klasse privat sind.
Beispiele für die Java-Kapselung
Sehen wir uns ein Beispiel für die Kapselung mit Getter- und Setter-Methoden an. Erstellen Sie dazu 2 Klassen - eine mit der Hauptmethode und eine mit den Methoden getting und set.
Beispiel 1
- Employee.java
Code:
//Java program for Encapsulation with both read and write
public class Employee (
//private variables which can be accessed by public methods of the class
private String EmpName;
private int EmpID;
private int EmpSal;
// get method to access the private integer variable EmpSal
public int getEmpSal()
(
return EmpSal;
)
// get method to access the private string variable EmpName
public String getEmpName()
(
return EmpName;
)
// get method to access the private integer variable EmpID
public int getEmpID()
(
return EmpID;
)
// set method to access the private integer variable EmpSal
public void setEmpSal( int EmpSal)
(
this.EmpSal = EmpSal;
)
// set method to access the private string variable EmpName
public void setEmpName(String EmpName)
(
this.EmpName = EmpName;
)
// set method to access the private integer variable EmpID
public void setEmpID( int EmpID)
(
this.EmpID = EmpID;
)
)
- EmployeeEncaps.java
Code:public class EmployeeEncaps (
public static void main(String() args) (
Employee EmpObj= new Employee(); //object of the class Employee
//passing the values to the methods using object
EmpObj.setEmpName("Anna");
EmpObj.setEmpSal(30000);
EmpObj.setEmpID(670311);
// Printing values of the variables
System.out.println("Employee's Name: " + EmpObj.getEmpName());
System.out.println("Employee's ID: " + EmpObj.getEmpID());
System.out.println("Employee's Salary: " + EmpObj.getEmpSal());
)
)
Ausgabe:
In dem obigen Programm ist die Klasse Employee gekapselt, da die Variablen privat sind. Es ist möglich, die Implementierung zu lesen und zu schreiben, da sie Methoden hat und setzt. Auf die privaten Variablen wie EmpName, EmpSal, EmpID wird mit diesen Methoden zugegriffen und durch Aufrufen der Methoden über das Objekt angezeigt.
Lassen Sie uns nun sehen, wie die Kapselung mit der schreibgeschützten Klasse funktioniert.
Beispiel 2
- Employee.java
Code:
//Java program for Encapsulation with read permission
public class Employee (
//private variables which can be accessed by public methods of the class
private String EmpName = "Adam";
private int EmpID = 670388;
private int EmpSal = 35000;
// get method to access the private integer variable EmpSal
public int getEmpSal()
(return EmpSal;
)// get method to access the private string variable EmpName
public String getEmpName()
(
return EmpName;
)
// get method to access the private integer variable EmpID
public int getEmpID()
(
return EmpID;
)
)
- EmployeeEncaps.java
Code:
public class EmployeeEncaps (
public static void main(String() args) (
Employee EmpObj= new Employee(); //object of the class Employee
// Printing values of the variables
System.out.println("Employee's Name: " + EmpObj.getEmpName());
System.out.println("Employee's ID: " + EmpObj.getEmpID());
System.out.println("Employee's Salary: " + EmpObj.getEmpSal());
)
)
Ausgabe:
Ähnlich wie im ersten Beispiel verwenden wir auch hier private Variablen. Der Unterschied besteht darin, dass wir nicht die Methode set verwenden, um Werte für die privaten Variablen in der Klasse festzulegen. Stattdessen weisen wir den Variablen den Wert direkt zu.
Jetzt können wir fortfahren, nur Klasse zu schreiben.
Beispiel 3
- Employee.java
Code:
//Java program for Encapsulation with write permission
public class Employee (
//private variables which can be accessed by public methods of the class
private String EmpName;
private int EmpID;
private int EmpSal;
// set method to access the private integer variable EmpSal
public void setEmpSal( int EmpSal)
(
this.EmpSal = EmpSal;
//for sample output
System.out.println("Employee's Salary: " + EmpSal);
)
// set method to access the private string variable EmpName
public void setEmpName(String EmpName)
(
this.EmpName = EmpName;
//for sample output
System.out.println("Employee's Name: " + EmpName);
)// set method to access the private integer variable EmpID
public void setEmpID( int EmpID)
(
this.EmpID = EmpID;
//for sample output
System.out.println("Employee's ID: " + EmpID);
)
)
- EmployeeEncaps.java
Code:
public class EmployeeEncaps (
public static void main(String() args) (
Employee EmpObj = new Employee(); //object of the class Employee
//passing the values to the methods using object
EmpObj.setEmpName("Iza");
EmpObj.setEmpID(670472);
EmpObj.setEmpSal(48000);
)
)
Ausgabe:
Im obigen Beispiel verwenden wir keine get-Methode, um eine reine Schreibklasse zu erreichen. dh die Variablen können hier nicht geändert oder abgerufen werden. Da es nicht möglich ist, die Werte abzurufen, verwenden wir print innerhalb der eingestellten Methode für die Beispielausgabe.
Fazit
Die Kapselung ist ein OOP-Konzept, bei dem die Daten so verpackt werden, dass alle Implementierungsdetails verborgen bleiben. Dies kann erreicht werden, indem private Variablen und Methoden verwendet werden, um auf die Variablen zuzugreifen. Die Hauptvorteile der Kapselung sind Flexibilität, Ausblenden von Daten, einfache Tests und Wiederverwendbarkeit .
Empfohlene Artikel
Dies war eine Anleitung zur Kapselung in Java. Hier diskutieren wir, wie die Kapselung funktioniert, Beispiele für die Java-Kapselung mit Codes und die Ausgabe. Sie können auch in unseren Artikeln nachlesen, um mehr zu erfahren.
- Destruktor in Java
- Layout in Java
- Beste Java-Compiler
- Leitfaden zur Kapselung in C ++
- Warum brauchen wir Encapsulation in C?
- Übersicht über die Kapselung in JavaScript