Kapselung in Java ist ein grundlegendes Konzept in der objektorientierten Programmierung (OOP), das sich auf die Bündelung von Daten und Methoden bezieht, die mit diesen Daten innerhalb einer einzigen Einheit arbeiten, die in Java als Klasse bezeichnet wird. Java Encapsulation ist eine Möglichkeit, die Implementierungsdetails einer Klasse vor dem Zugriff von außen zu verbergen und nur eine öffentliche Schnittstelle offenzulegen, die zur Interaktion mit der Klasse verwendet werden kann.
In Java wird die Kapselung erreicht, indem die Instanzvariablen einer Klasse als privat deklariert werden, was bedeutet, dass auf sie nur innerhalb der Klasse zugegriffen werden kann. Um den Zugriff von außen auf die Instanzvariablen zu ermöglichen, werden öffentliche Methoden namens Getter und Setter definiert, mit denen die Werte der Instanzvariablen abgerufen bzw. geändert werden. Durch die Verwendung von Gettern und Settern kann die Klasse ihre eigenen Datenvalidierungsregeln durchsetzen und sicherstellen, dass ihr interner Zustand konsistent bleibt.
Implementierung der Java-Kapselung
Unten ist das Beispiel mit Java Encapsulation:
Java
// Java Program to demonstrate> // Java Encapsulation> // Person Class> class> Person {> >// Encapsulating the name and age> >// only approachable and used using> >// methods defined> >private> String name;> >private> int> age;> >public> String getName() {>return> name; }> >public> void> setName(String name) {>this>.name = name; }> >public> int> getAge() {>return> age; }> >public> void> setAge(>int> age) {>this>.age = age; }> }> // Driver Class> public> class> Main {> >// main function> >public> static> void> main(String[] args)> >{> >// person object created> >Person person =>new> Person();> >person.setName(>'John'>);> >person.setAge(>30>);> >// Using methods to get the values from the> >// variables> >System.out.println(>'Name: '> + person.getName());> >System.out.println(>'Age: '> + person.getAge());> >}> }> |
>
>Ausgabe
Name: John Age: 30>
Verkapselung ist definiert als das Zusammenfassen von Daten unter einer einzigen Einheit. Es ist der Mechanismus, der Code und die von ihm manipulierten Daten miteinander verbindet. Eine andere Möglichkeit, über Kapselung nachzudenken, besteht darin, dass es sich um einen Schutzschild handelt, der verhindert, dass der Code außerhalb dieses Schutzschilds auf die Daten zugreift.
nfa zu dfa
- Technisch gesehen sind die Variablen oder Daten einer Klasse bei der Kapselung vor jeder anderen Klasse verborgen und können nur über eine beliebige Mitgliedsfunktion der eigenen Klasse, in der sie deklariert sind, aufgerufen werden.
- Wie bei der Kapselung werden die Daten in einer Klasse vor anderen Klassen verborgen, indem das Konzept des Datenverbergens verwendet wird, das dadurch erreicht wird, dass die Mitglieder oder Methoden einer Klasse privat gemacht werden, und die Klasse wird dem Endbenutzer oder der Welt zugänglich gemacht, ohne irgendwelche Details anzugeben hinter der Implementierung unter Verwendung des Abstraktionskonzepts, daher wird es auch als a bezeichnet Kombination aus Datenverbergung und Abstraktion .
- Die Kapselung kann erreicht werden, indem alle Variablen in der Klasse als privat deklariert und öffentliche Methoden in die Klasse geschrieben werden, um die Werte von Variablen festzulegen und abzurufen.
- Mit der Setter- und Getter-Methode wird es genauer definiert.
Vorteile der Kapselung
- Ausblenden von Daten: Dies ist eine Möglichkeit, den Zugriff unserer Datenmitglieder einzuschränken, indem die Implementierungsdetails ausgeblendet werden. Die Kapselung bietet auch eine Möglichkeit, Daten zu verbergen. Der Benutzer hat keine Ahnung von der inneren Implementierung der Klasse. Für den Benutzer ist nicht sichtbar, wie die Klasse Werte in den Variablen speichert. Der Benutzer weiß nur, dass wir die Werte an eine Setter-Methode übergeben und Variablen mit diesem Wert initialisiert werden.
- Erhöhte Flexibilität: Wir können die Variablen der Klasse je nach unseren Anforderungen schreibgeschützt oder schreibgeschützt machen. Wenn wir die Variablen schreibgeschützt machen möchten, müssen wir die Setter-Methoden wie setName(), setAge() usw. aus dem obigen Programm weglassen, oder wenn wir die Variablen schreibgeschützt machen möchten, müssen wir die weglassen Holen Sie sich Methoden wie getName(), getAge() usw. aus dem obigen Programm
- Wiederverwendbarkeit: Die Kapselung verbessert zudem die Wiederverwendbarkeit und lässt sich leicht an neue Anforderungen anpassen.
- Das Testen von Code ist einfach: Gekapselter Code lässt sich für Unit-Tests leicht testen.
- Freiheit des Programmierers bei der Implementierung der Details des Systems: Dies ist einer der Hauptvorteile der Kapselung, da sie dem Programmierer Freiheit bei der Implementierung der Details eines Systems gibt. Die einzige Einschränkung für den Programmierer besteht darin, die abstrakte Schnittstelle beizubehalten, die Außenstehende sehen.
Zum Beispiel: Der Programmierer des Bearbeitungsmenücodes in einer Texteditor-GUI implementiert möglicherweise zunächst die Ausschneide- und Einfügevorgänge, indem er tatsächliche Bildschirmbilder in einen externen Puffer kopiert und aus diesem heraus kopiert. Später könnte er/sie mit dieser Implementierung unzufrieden sein, da sie keine kompakte Speicherung der Auswahl ermöglicht und nicht zwischen Text- und Grafikobjekten unterscheidet. Wenn der Programmierer die Schnittstelle zum Ausschneiden und Einfügen unter Berücksichtigung der Kapselung entworfen hat, sollte die Umstellung der zugrunde liegenden Implementierung auf eine, die Text als Text- und Grafikobjekte in einem geeigneten kompakten Format speichert, keine Probleme für Funktionen verursachen, die eine Schnittstelle mit dieser GUI benötigen . Daher sorgt die Kapselung für Anpassungsfähigkeit, da sie die Änderung der Implementierungsdetails von Teilen eines Programms ermöglicht, ohne dass sich dies negativ auf andere Teile auswirkt.
Nachteile der Kapselung in Java
- Kann zu erhöhter Komplexität führen, insbesondere bei unsachgemäßer Anwendung.
- Kann es schwieriger machen, die Funktionsweise des Systems zu verstehen.
- Kann die Flexibilität der Implementierung einschränken.
Beispiele, die die Datenkapselung in Java zeigen
Beispiel 1:
Nachfolgend finden Sie die Umsetzung des oben genannten Themas:
Java
// Java Program to demonstrate> // Java Encapsulation> // fields to calculate area> class> Area {> >int> length;> >int> breadth;> >// constructor to initialize values> >Area(>int> length,>int> breadth)> >{> >this>.length = length;> >this>.breadth = breadth;> >}> >// method to calculate area> >public> void> getArea()> >{> >int> area = length * breadth;> >System.out.println(>'Area: '> + area);> >}> }> class> Main {> >public> static> void> main(String[] args)> >{> >Area rectangle =>new> Area(>2>,>16>);> >rectangle.getArea();> >}> }> |
>
>Ausgabe
Area: 32>
Beispiel 2:
Das Programm zum Zugriff auf Variablen der Klasse EncapsulateDemo ist unten dargestellt:
Java
// Java program to demonstrate> // Java encapsulation> class> Encapsulate {> >// private variables declared> >// these can only be accessed by> >// public methods of class> >private> String geekName;> >private> int> geekRoll;> >private> int> geekAge;> >// get method for age to access> >// private variable geekAge> >public> int> getAge() {>return> geekAge; }> >// get method for name to access> >// private variable geekName> >public> String getName() {>return> geekName; }> >// get method for roll to access> >// private variable geekRoll> >public> int> getRoll() {>return> geekRoll; }> >// set method for age to access> >// private variable geekage> >public> void> setAge(>int> newAge) { geekAge = newAge; }> >// set method for name to access> >// private variable geekName> >public> void> setName(String newName)> >{> >geekName = newName;> >}> >// set method for roll to access> >// private variable geekRoll> >public> void> setRoll(>int> newRoll) { geekRoll = newRoll; }> }> public> class> TestEncapsulation {> >public> static> void> main(String[] args)> >{> >Encapsulate obj =>new> Encapsulate();> >// setting values of the variables> >obj.setName(>'Harsh'>);> >obj.setAge(>19>);> >obj.setRoll(>51>);> >// Displaying values of the variables> >System.out.println(>'Geek's name: '> + obj.getName());> >System.out.println(>'Geek's age: '> + obj.getAge());> >System.out.println(>'Geek's roll: '> + obj.getRoll());> >// Direct access of geekRoll is not possible> >// due to encapsulation> >// System.out.println('Geek's roll: ' +> >// obj.geekName);> >}> }> |
>
>Ausgabe
Geek's name: Harsh Geek's age: 19 Geek's roll: 51>
Beispiel 3:
Im obigen Programm wird die Klasse Encapsulate gekapselt, da die Variablen als privat deklariert werden. Die Get-Methoden wie getAge(), getName() und getRoll() sind als öffentlich festgelegt. Diese Methoden werden für den Zugriff auf diese Variablen verwendet. Die Setter-Methoden wie setName(), setAge(), setRoll() werden ebenfalls als öffentlich deklariert und werden zum Festlegen der Werte der Variablen verwendet.
Nachfolgend finden Sie die Implementierung des definierten Beispiels:
Java
// Java Program to demonstrate> // Java Encapsulation> class> Name {> >// Private is using to hide the data> >private> int> age;> >// getter> >public> int> getAge() {>return> age; }> >// setter> >public> void> setAge(>int> age) {>this>.age = age; }> }> // Driver Class> class> GFG {> >// main function> >public> static> void> main(String[] args)> >{> >Name n1 =>new> Name();> >n1.setAge(>19>);> >System.out.println(>'The age of the person is: '> >+ n1.getAge());> >}> }> |
>
>Ausgabe
The age of the person is: 19>
Beispiel 4:
Unten ist die Implementierung der Java-Kapselung:
Java
// Java Program to demonstrate> // Java Encapsulation> class> Account {> >// private data members to hide the data> >private> long> acc_no;> >private> String name, email;> >private> float> amount;> >// public getter and setter methods> >public> long> getAcc_no() {>return> acc_no; }> >public> void> setAcc_no(>long> acc_no)> >{> >this>.acc_no = acc_no;> >}> >public> String getName() {>return> name; }> >public> void> setName(String name) {>this>.name = name; }> >public> String getEmail() {>return> email; }> >public> void> setEmail(String email)> >{> >this>.email = email;> >}> >public> float> getAmount() {>return> amount; }> >public> void> setAmount(>float> amount)> >{> >this>.amount = amount;> >}> }> // Driver Class> public> class> GFG {> >// main function> >public> static> void> main(String[] args)> >{> >// creating instance of Account class> >Account acc =>new> Account();> >// setting values through setter methods> >acc.setAcc_no(90482098491L);> >acc.setName(>'ABC'>);> >acc.setEmail(>'[email protected]'>);> >acc.setAmount(100000f);> >// getting values through getter methods> >System.out.println(> >acc.getAcc_no() +>' '> + acc.getName() +>' '> >+ acc.getEmail() +>' '> + acc.getAmount());> >}> }> |
>
>Ausgabe
90482098491 ABC [email protected] 100000.0>