Iekapsulēšana Java ir objektorientētās programmēšanas (OOP) pamatjēdziens, kas attiecas uz datu un metožu apvienošanu, kas darbojas ar šiem datiem vienā vienībā, ko Java sauc par klasi. Java iekapsulēšana ir veids, kā paslēpt klases ieviešanas informāciju no ārējās piekļuves un tikai atklāt publisku saskarni, ko var izmantot, lai mijiedarbotos ar klasi.
Java programmā iekapsulēšana tiek panākta, deklarējot klases gadījumu mainīgos kā privātus, kas nozīmē, ka tiem var piekļūt tikai klasē. Lai ļautu ārējai piekļuvei instances mainīgajiem, tiek definētas publiskās metodes, ko sauc par ieguvējiem un iestatītājiem, kuras tiek izmantotas, lai attiecīgi izgūtu un modificētu instanču mainīgo vērtības. Izmantojot ieguvējus un iestatītājus, klase var ieviest savus datu validācijas noteikumus un nodrošināt, ka tās iekšējais stāvoklis paliek nemainīgs.
Java iekapsulēšanas ieviešana
Tālāk ir sniegts Java iekapsulēšanas piemērs:
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());> >}> }> |
git statuss -s
>
>Izvade
Name: John Age: 30>
Iekapsulēšana ir definēts kā datu apkopošana vienā vienībā. Tas ir mehānisms, kas saista kopā kodu un datus, ar kuriem tas manipulē. Vēl viens veids, kā domāt par iekapsulēšanu, ir tas, ka tas ir aizsargvairogs, kas neļauj datiem piekļūt kodam ārpus šī vairoga.
- Tehniski iekapsulācijā klases mainīgie vai dati ir paslēpti no jebkuras citas klases, un tiem var piekļūt tikai caur jebkuru savas klases dalībfunkciju, kurā tie ir deklarēti.
- Tāpat kā iekapsulācijā, klases dati tiek paslēpti no citām klasēm, izmantojot datu slēpšanas koncepciju, kas tiek panākta, padarot klases dalībniekus vai metodes privātus, un klase tiek pakļauta galalietotājam vai pasaulei, nesniedzot nekādu informāciju. aiz īstenošanas, izmantojot abstrakcijas jēdzienu, tāpēc to sauc arī par a datu slēpšanas un abstrakcijas kombinācija .
- Iekapsulēšanu var panākt, deklarējot visus klases mainīgos par privātiem un ierakstot klasē publiskas metodes, lai iestatītu un iegūtu mainīgo vērtības.
- Tas ir vairāk definēts ar setera un ieguvēja metodi.
Iekapsulēšanas priekšrocības
- Datu slēpšana: tas ir veids, kā ierobežot mūsu datu dalībnieku piekļuvi, slēpjot ieviešanas informāciju. Iekapsulēšana nodrošina arī datu slēpšanas veidu. Lietotājam nebūs ne jausmas par klases iekšējo ieviešanu. Lietotājam nebūs redzams, kā klase saglabā vērtības mainīgajos. Lietotājs zinās tikai to, ka mēs nododam vērtības iestatīšanas metodei un mainīgie tiek inicializēti ar šo vērtību.
- Paaugstināta elastība: Mēs varam padarīt klases mainīgos tikai lasāmus vai tikai rakstāmus atkarībā no mūsu prasībām. Ja mēs vēlamies, lai mainīgie būtu tikai lasāmi, tad mums ir jāizlaiž iestatīšanas metodes, piemēram, setName(), setAge() utt. no iepriekšminētās programmas vai, ja mēs vēlamies, lai mainīgie būtu tikai rakstāmi, mums ir jāizlaiž no iepriekš minētās programmas iegūstiet tādas metodes kā getName(), getAge() utt
- Atkārtota izmantošana: Iekapsulēšana arī uzlabo atkārtotu lietojamību un ir viegli maināma atbilstoši jaunām prasībām.
- Testēšanas kods ir vienkāršs: Iekapsulēto kodu ir viegli pārbaudīt vienības testēšanai.
- Programmētāja brīvība, ieviešot sistēmas detaļas: Šī ir viena no galvenajām iekapsulēšanas priekšrocībām, jo tā programmētājam dod brīvību sistēmas detaļu ieviešanā. Vienīgais programmētāja ierobežojums ir saglabāt abstraktu saskarni, ko redz nepiederošie.
Piemēram: Rediģēšanas izvēlnes koda programmētājs teksta redaktora GUI sākumā var veikt izgriešanas un ielīmēšanas darbības, kopējot faktiskos ekrāna attēlus ārējā buferī un no tā. Vēlāk viņš var būt neapmierināts ar šo ieviešanu, jo tas neļauj kompakti saglabāt atlasi, kā arī neatšķir teksta un grafiskos objektus. Ja programmētājs ir izstrādājis izgriešanas un ielīmēšanas saskarni, paturot prātā iekapsulēšanu, pamatā esošās implementācijas pārslēgšana uz tādu, kas saglabā tekstu kā teksta un grafiskus objektus atbilstošā kompaktā formātā, nedrīkst radīt problēmas funkcijās, kurām nepieciešams saskarne ar šo GUI. . Tādējādi iekapsulēšana nodrošina pielāgojamību, jo tā ļauj mainīt programmas daļu īstenošanas detaļas, negatīvi neietekmējot citas daļas.
Java iekapsulēšanas trūkumi
- Var palielināt sarežģītību, īpaši, ja to neizmanto pareizi.
- Var apgrūtināt sistēmas darbības izpratni.
- Var ierobežot ieviešanas elastību.
Piemēri, kas parāda datu iekapulāciju Java
1. piemērs:
Zemāk ir aprakstīta iepriekš minētās tēmas īstenošana:
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();> >}> }> |
>
>Izvade
Area: 32>
2. piemērs:
Programma, lai piekļūtu klases EncapsulateDemo mainīgajiem, ir parādīta zemāk:
Java
java krāsas
// 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);> >}> }> |
>
>Izvade
Geek's name: Harsh Geek's age: 19 Geek's roll: 51>
3. piemērs:
Iepriekš minētajā programmā klase Encapsulate ir iekapsulēta, jo mainīgie tiek deklarēti kā privāti. Iegūšanas metodes, piemēram, getAge(), getName() un getRoll() ir iestatītas kā publiskas, šīs metodes tiek izmantotas, lai piekļūtu šiem mainīgajiem. Tādas iestatīšanas metodes kā setName(), setAge(), setRoll() arī tiek deklarētas kā publiskas un tiek izmantotas mainīgo vērtību iestatīšanai.
Tālāk ir sniegta definētā piemēra ieviešana:
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());> >}> }> |
>
>Izvade
The age of the person is: 19>
4. piemērs:
Tālāk ir norādīta Java iekapsulēšanas ieviešana:
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());> >}> }> |
>
>Izvade
90482098491 ABC [email protected] 100000.0>