Javan kapselointi on olio-ohjelmoinnin (OOP) peruskäsite, joka viittaa tietojen ja menetelmien yhdistämiseen, jotka toimivat kyseisellä tiedolla yhdessä yksikössä, jota kutsutaan Javassa luokaksi. Java-kapselointi on tapa piilottaa luokan toteutustiedot ulkopuolelta ja paljastaa vain julkinen käyttöliittymä, jota voidaan käyttää vuorovaikutuksessa luokan kanssa.
Javassa kapselointi saavutetaan ilmoittamalla luokan ilmentymämuuttujat yksityisiksi, mikä tarkoittaa, että niihin pääsee vain luokassa. Jotta ulkopuoliset pääsevät käsiksi ilmentymämuuttujiin, määritellään julkiset menetelmät nimeltä getters ja setters, joita käytetään vastaavasti ilmentymämuuttujien arvojen noutamiseen ja muokkaamiseen. Käyttämällä gettereitä ja asettimia luokka voi pakottaa omat datan validointisääntönsä ja varmistaa, että sen sisäinen tila pysyy johdonmukaisena.
Java-kapseloinnin toteutus
Alla on esimerkki Java-kapseloinnista:
kirjoita json tiedostoon python
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());> >}> }> |
>
>Lähtö
Name: John Age: 30>
Kapselointi määritellään tietojen käämittämiseksi yhden yksikön alle. Se on mekanismi, joka sitoo yhteen koodin ja sen käsittelemän tiedon. Toinen tapa ajatella kapselointia on, että se on suojakilpi, joka estää koodin pääsyn dataan tämän suojan ulkopuolella.
- Teknisesti kapseloituna luokan muuttujat tai tiedot ovat piilossa kaikilta muilta luokilta ja niihin pääsee vain minkä tahansa oman luokan jäsenfunktion kautta, jossa se on ilmoitettu.
- Kuten kapseloinnissa, luokan tiedot piilotetaan muilta luokilta datan piilotuskonseptilla, joka saavutetaan tekemällä luokan jäsenet tai menetelmät yksityisiksi, ja luokka paljastetaan loppukäyttäjälle tai maailmalle antamatta mitään yksityiskohtia. abstraktiokonseptia käyttävän toteutuksen takana, joten se tunnetaan myös nimellä a tietojen piilottamisen ja abstraktion yhdistelmä .
- Kapselointi voidaan saavuttaa ilmoittamalla kaikki luokan muuttujat yksityisiksi ja kirjoittamalla luokkaan julkisia menetelmiä muuttujien arvojen asettamiseksi ja saamiseksi.
- Se määritellään paremmin setter- ja getter-menetelmällä.
Kapseloinnin edut
- Tietojen piilottaminen: se on tapa rajoittaa datajäsentemme pääsyä piilottamalla toteutustiedot. Kapselointi tarjoaa myös tavan tietojen piilottamiseen. Käyttäjällä ei ole aavistustakaan luokan sisäisestä toteutuksesta. Käyttäjä ei näe, kuinka luokka tallentaa arvoja muuttujiin. Käyttäjä tietää vain, että välitämme arvot setter-menetelmälle ja muuttujat alustetaan tällä arvolla.
- Lisääntynyt joustavuus: Voimme tehdä luokan muuttujista vain luku - tai vain kirjoitettavat tarpeidemme mukaan. Jos haluamme tehdä muuttujista vain luku -muotoisia, meidän on jätettävä pois setter-metodit, kuten setName(), setAge() jne. yllä olevasta ohjelmasta tai jos haluamme tehdä muuttujista vain kirjoitettavia, meidän on jätettävä pois Hanki menetelmät, kuten getName(), getAge() jne. yllä olevasta ohjelmasta
- Uudelleenkäytettävyys: Kapselointi parantaa myös uudelleenkäytettävyyttä ja on helppo muuttaa uusien vaatimusten mukaan.
- Koodin testaus on helppoa: Kapseloitu koodi on helppo testata yksikkötestausta varten.
- Ohjelmoijan vapaus toteuttaa järjestelmän yksityiskohtia: Tämä on yksi kapseloinnin suurimmista eduista, että se antaa ohjelmoijalle vapauden toteuttaa järjestelmän yksityiskohtia. Ainoa ohjelmoijan rajoitus on säilyttää ulkopuolisten näkemä abstrakti käyttöliittymä.
Esimerkiksi: Muokkausvalikkokoodin ohjelmoija tekstieditorin graafisessa käyttöliittymässä saattaa aluksi toteuttaa leikkaus- ja liittämistoiminnot kopioimalla todellisia näyttökuvia ulkoiseen puskuriin ja sieltä pois. Myöhemmin hän voi olla tyytymätön tähän toteutukseen, koska se ei salli valinnan kompaktia tallennusta, eikä se erota tekstiä ja grafiikkaa. Jos ohjelmoija on suunnitellut leikkaa ja liitä -käyttöliittymän kapselointia ajatellen, taustalla olevan toteutuksen vaihtaminen sellaiseen, joka tallentaa tekstin tekstinä ja graafisina objekteina sopivassa kompaktissa muodossa, ei saisi aiheuttaa ongelmia toiminnoille, joiden on liitettävä tähän graafiseen käyttöliittymään. . Siten kapselointi tuottaa mukautumiskykyä, sillä se sallii ohjelman osien toteutusyksityiskohtien muuttumisen vaikuttamatta haitallisesti muihin osiin.
Java-kapseloinnin haitat
- Voi lisätä monimutkaisuutta, varsinkin jos sitä ei käytetä oikein.
- Voi vaikeuttaa järjestelmän toiminnan ymmärtämistä.
- Saattaa rajoittaa toteutuksen joustavuutta.
Esimerkkejä tietojen kapseloinnin näyttämisestä Javassa
Esimerkki 1:
Alla on yllä olevan aiheen toteutus:
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();> >}> }> |
>
>Lähtö
Area: 32>
Esimerkki 2:
Alla on ohjelma, jolla pääset käsiksi luokan EncapsulateDemo muuttujiin:
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);> >}> }> |
>
>Lähtö
Geek's name: Harsh Geek's age: 19 Geek's roll: 51>
Esimerkki 3:
Yllä olevassa ohjelmassa luokka Encapsulate on kapseloitu, koska muuttujat ilmoitetaan yksityisiksi. Get-menetelmät, kuten getAge(), getName() ja getRoll() on asetettu julkisiksi, näitä menetelmiä käytetään näiden muuttujien käyttämiseen. Asetusmenetelmät, kuten setName(), setAge(), setRoll() on myös ilmoitettu julkisiksi ja niitä käytetään muuttujien arvojen asettamiseen.
Alla on määritellyn esimerkin toteutus:
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());> >}> }> |
>
>Lähtö
The age of the person is: 19>
Esimerkki 4:
Alla on Java-kapseloinnin toteutus:
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());> >}> }> |
ubuntu build essentials
>
>Lähtö
90482098491 ABC [email protected] 100000.0>