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());> > }> }>

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

// 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 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