Innkapsling i Java er et grunnleggende konsept i objektorientert programmering (OOP) som refererer til bunting av data og metoder som opererer på disse dataene i en enkelt enhet, som kalles en klasse i Java. Java Encapsulation er en måte å skjule implementeringsdetaljene til en klasse fra tilgang utenfor og bare avsløre et offentlig grensesnitt som kan brukes til å samhandle med klassen.
I Java oppnås innkapsling ved å erklære forekomstvariablene til en klasse som private, noe som betyr at de kun kan nås innenfor klassen. For å tillate ekstern tilgang til forekomstvariablene, er offentlige metoder kalt getters og settere definert, som brukes til å hente og endre verdiene til forekomstvariablene, henholdsvis. Ved å bruke gettere og settere kan klassen håndheve sine egne datavalideringsregler og sikre at dens interne tilstand forblir konsistent.

Implementering av Java Encapsulation
Nedenfor er eksempelet med 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());> >}> }> |
css overgangsopasitet
>
>Produksjon
Name: John Age: 30>
Innkapsling er definert som innpakning av data under en enkelt enhet. Det er mekanismen som binder sammen kode og dataene den manipulerer. En annen måte å tenke på innkapsling er at det er et beskyttende skjold som forhindrer at dataene blir aksessert av koden utenfor dette skjoldet.
- Teknisk i innkapsling er variablene eller dataene til en klasse skjult for enhver annen klasse og kan bare nås gjennom en hvilken som helst medlemsfunksjon i sin egen klasse der den er deklarert.
- Som i innkapsling, er dataene i en klasse skjult fra andre klasser ved å bruke dataskjulingskonseptet som oppnås ved å gjøre medlemmene eller metodene til en klasse private, og klassen blir eksponert for sluttbrukeren eller verden uten å gi noen detaljer bak implementering ved hjelp av abstraksjonskonseptet, så det er også kjent som en kombinasjon av dataskjuling og abstraksjon .
- Innkapsling kan oppnås ved å erklære alle variablene i klassen som private og skrive offentlige metoder i klassen for å sette og hente verdiene til variabler.
- Det er mer definert med setter og getter-metoden.
Fordeler med innkapsling
- Skjul data: det er en måte å begrense tilgangen til våre datamedlemmer ved å skjule implementeringsdetaljene. Innkapsling gir også en måte å skjule data på. Brukeren vil ikke ha noen formening om den indre gjennomføringen av klassen. Det vil ikke være synlig for brukeren hvordan klassen lagrer verdier i variablene. Brukeren vil bare vite at vi sender verdiene til en settermetode og variabler blir initialisert med den verdien.
- Økt fleksibilitet: Vi kan gjøre variablene i klassen skrivebeskyttet eller skrivebeskyttet avhengig av kravene våre. Hvis vi ønsker å gjøre variablene skrivebeskyttede, må vi utelate setter-metodene som setName(), setAge(), etc. fra programmet ovenfor, eller hvis vi ønsker å gjøre variablene skrivebeskyttede, må vi utelate få metoder som getName(), getAge(), etc. fra programmet ovenfor
- Gjenbrukbarhet: Innkapsling forbedrer også gjenbrukbarheten og er lett å endre med nye krav.
- Det er enkelt å teste kode: Innkapslet kode er enkel å teste for enhetstesting.
- Frihet til å programmere i implementering av detaljene i systemet: Dette er en av de største fordelene med innkapsling at det gir programmereren frihet til å implementere detaljene i et system. Den eneste begrensningen for programmereren er å opprettholde det abstrakte grensesnittet som utenforstående ser.
For eksempel: Programmereren av redigeringsmenykoden i et tekstredigeringsgrensesnitt kan til å begynne med implementere klippe- og limoperasjonene ved å kopiere faktiske skjermbilder inn og ut av en ekstern buffer. Senere kan han/hun være misfornøyd med denne implementeringen, siden den ikke tillater kompakt lagring av utvalget, og den skiller ikke mellom tekst og grafiske objekter. Hvis programmereren har designet klipp-og-lim-grensesnittet med innkapsling i tankene, bør det å bytte den underliggende implementeringen til en som lagrer tekst som tekst og grafiske objekter i et passende kompakt format ikke forårsake problemer for funksjoner som trenger å ha grensesnitt med denne GUI. . Dermed gir innkapsling tilpasningsevne, for den lar implementeringsdetaljene til deler av et program endres uten å påvirke andre deler negativt.
Ulemper med innkapsling i Java
- Kan føre til økt kompleksitet, spesielt hvis den ikke brukes riktig.
- Kan gjøre det vanskeligere å forstå hvordan systemet fungerer.
- Kan begrense fleksibiliteten til implementeringen.
Eksempler som viser datainnkapsling i Java
Eksempel 1:
Nedenfor er implementeringen av emnet ovenfor:
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();> >}> }> |
>
>Produksjon
Area: 32>
Eksempel 2:
Programmet for å få tilgang til variabler i klassen EncapsulateDemo er vist nedenfor:
Java
de tidlige mukere
// 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);> >}> }> |
>
>Produksjon
Geek's name: Harsh Geek's age: 19 Geek's roll: 51>
Eksempel 3:
I programmet ovenfor er klassen Encapsulate innkapslet ettersom variablene er erklært private. Get-metodene som getAge(), getName() og getRoll() er satt som offentlige, disse metodene brukes for å få tilgang til disse variablene. Settermetodene som setName(), setAge(), setRoll() er også erklært som offentlige og brukes til å angi verdiene til variablene.
Nedenfor er implementeringen av det definerte eksemplet:
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());> >}> }> |
>
>Produksjon
The age of the person is: 19>
Eksempel 4:
Nedenfor er implementeringen av Java Encapsulation:
Java
java char til heltall
// 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());> >}> }> |
>
>Produksjon
90482098491 ABC [email protected] 100000.0>