Inkapseling in Java is een fundamenteel concept in objectgeoriënteerd programmeren (OOP) dat verwijst naar het bundelen van gegevens en methoden die op die gegevens werken binnen een enkele eenheid, die in Java een klasse wordt genoemd. Java Encapsulation is een manier om de implementatiedetails van een klasse te verbergen voor toegang van buitenaf en alleen een openbare interface bloot te leggen die kan worden gebruikt voor interactie met de klasse.
In Java wordt inkapseling bereikt door de instantievariabelen van een klasse als privé te declareren, wat betekent dat ze alleen toegankelijk zijn binnen de klasse. Om toegang van buitenaf tot de instantievariabelen mogelijk te maken, zijn openbare methoden gedefinieerd, genaamd getters en setters, die worden gebruikt om respectievelijk de waarden van de instantievariabelen op te halen en te wijzigen. Door getters en setters te gebruiken, kan de klasse zijn eigen regels voor gegevensvalidatie afdwingen en ervoor zorgen dat de interne status consistent blijft.
Implementatie van Java-encapsulatie
Hieronder ziet u het voorbeeld met Java Encapsulation:
Java
kern Java-taal
// 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());> >}> }> |
>
>Uitvoer
Name: John Age: 30>
Inkapseling wordt gedefinieerd als het samenbrengen van gegevens onder één enkele eenheid. Het is het mechanisme dat code en de gegevens die het manipuleert met elkaar verbindt. Een andere manier om over inkapseling na te denken is dat het een beschermend schild is dat voorkomt dat de gegevens toegankelijk zijn voor de code buiten dit schild.
- Technisch gezien zijn bij inkapseling de variabelen of gegevens van een klasse verborgen voor elke andere klasse en zijn ze alleen toegankelijk via elke lidfunctie van de eigen klasse waarin deze is gedeclareerd.
- Net als bij inkapseling worden de gegevens in een klasse verborgen voor andere klassen met behulp van het concept voor het verbergen van gegevens, dat wordt bereikt door de leden of methoden van een klasse privé te maken, en de klasse wordt blootgesteld aan de eindgebruiker of de wereld zonder enige details te verstrekken. achter de implementatie met behulp van het abstractieconcept, dus het staat ook bekend als a combinatie van gegevens verbergen en abstractie .
- Inkapseling kan worden bereikt door alle variabelen in de klasse als privé te declareren en openbare methoden in de klasse te schrijven om de waarden van variabelen in te stellen en op te halen.
- Het wordt meer gedefinieerd met de setter en getter-methode.
Voordelen van inkapseling
- Gegevens verbergen: het is een manier om de toegang van onze gegevensleden te beperken door de implementatiedetails te verbergen. Inkapseling biedt ook een manier om gegevens te verbergen. De gebruiker heeft geen idee van de innerlijke implementatie van de klasse. Het zal voor de gebruiker niet zichtbaar zijn hoe de klasse waarden in de variabelen opslaat. De gebruiker weet alleen dat we de waarden doorgeven aan een settermethode en dat variabelen met die waarde worden geïnitialiseerd.
- Verhoogde flexibiliteit: We kunnen de variabelen van de klasse alleen-lezen of alleen-schrijven maken, afhankelijk van onze vereisten. Als we de variabelen alleen-lezen willen maken, moeten we de setter-methoden zoals setName(), setAge(), enz. uit het bovenstaande programma weglaten of als we de variabelen alleen-schrijven willen maken, dan moeten we de haal methoden zoals getName(), getAge(), etc. op uit het bovenstaande programma
- Herbruikbaarheid: Inkapseling verbetert ook de herbruikbaarheid en is gemakkelijk te veranderen bij nieuwe eisen.
- Code testen is eenvoudig: Ingekapselde code is eenvoudig te testen voor het testen van eenheden.
- Vrijheid voor programmeur bij het implementeren van de details van het systeem: Dit is een van de belangrijkste voordelen van inkapseling: het geeft de programmeur vrijheid bij het implementeren van de details van een systeem. De enige beperking voor de programmeur is het behouden van de abstracte interface die buitenstaanders zien.
Bijvoorbeeld: De programmeur van de bewerkingsmenucode in een teksteditor-GUI zou in eerste instantie de knip- en plakbewerkingen kunnen implementeren door feitelijke schermafbeeldingen in en uit een externe buffer te kopiëren. Later kan hij/zij ontevreden zijn over deze implementatie, omdat deze geen compacte opslag van de selectie mogelijk maakt en er geen onderscheid wordt gemaakt tussen tekst en grafische objecten. Als de programmeur de knip-en-plakinterface heeft ontworpen met inkapseling in gedachten, zou het overschakelen van de onderliggende implementatie naar een implementatie die tekst opslaat als tekst en grafische objecten in een geschikt compact formaat geen problemen mogen veroorzaken voor functies die met deze GUI moeten communiceren. . Inkapseling levert dus aanpassingsvermogen op, omdat het de implementatiedetails van delen van een programma mogelijk maakt om te veranderen zonder andere delen nadelig te beïnvloeden.
Nadelen van inkapseling op Java
- Kan leiden tot een grotere complexiteit, vooral als het niet op de juiste manier wordt gebruikt.
- Kan het moeilijker maken om te begrijpen hoe het systeem werkt.
- Kan de flexibiliteit van de implementatie beperken.
Voorbeelden van gegevensinkapseling in Java
Voorbeeld 1:
Hieronder vindt u de implementatie van het bovenstaande onderwerp:
Java
1 miljard tot miljoen
// 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();> >}> }> |
>
>Uitvoer
Area: 32>
Voorbeeld 2:
Het programma voor toegang tot variabelen van de klasse EncapsulateDemo wordt hieronder weergegeven:
Java
wat is desktop.ini
// 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);> >}> }> |
>
>Uitvoer
Geek's name: Harsh Geek's age: 19 Geek's roll: 51>
Voorbeeld 3:
In het bovenstaande programma is de klasse Encapsulate ingekapseld wanneer de variabelen privé worden verklaard. De get-methoden zoals getAge(), getName() en getRoll() zijn ingesteld als openbaar, deze methoden worden gebruikt om toegang te krijgen tot deze variabelen. De settermethoden zoals setName(), setAge() en setRoll() worden ook als openbaar gedeclareerd en worden gebruikt om de waarden van de variabelen in te stellen.
Hieronder ziet u de implementatie van het gedefinieerde voorbeeld:
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());> >}> }> |
>
>Uitvoer
The age of the person is: 19>
Voorbeeld 4:
Hieronder ziet u de implementatie van de Java-inkapseling:
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());> >}> }> |
>
referentievariabele in Java
>Uitvoer
90482098491 ABC [email protected] 100000.0>