Меню

Капсулиране в Java: Пълно ръководство с примери

encapsulation java

Опитайте Нашия Инструмент За Премахване На Проблемите

Научете за капсулирането в Java с примери, защо се нуждаем от него, свързани методи за получаване и задаване:

В този урок ще обсъдим друга концепция за ООП - „капсулиране“. OOP има четири стълба, а именно абстракция, капсулиране, полиморфизъм и наследяване.

Докато абстракцията се използва за излагане само на съответните подробности на крайния потребител, капсулирането се занимава главно със сигурността на данните. При осигуряване на сигурност на данните, капсулирането предпазва членовете на данните от нежелан достъп, като посочва модификатори за достъп, а също така обединява данните в една единица.

c ++ списък за съседство неориентирана графика

=> Вижте Перфектното ръководство за обучение по Java тук.

Капсулиране в Java

И така, как можем да определим капсулирането в Java?

Определение за капсулиране

„Капсулирането в Java може да се определи като механизъм, чрез който данните и методите, които работят върху тези данни, се обвиват, за да образуват една единица.“

Какво ще научите:

Какво е капсулиране в Java

Използвайки капсулиране, ние също можем да скрием членовете на данните за класа (променливи) от останалите класове. Тези променливи на членове на данни могат да бъдат достъпни непряко, като се използват методи от класа, в който са декларирани. Методите от своя страна са достъпни с помощта на обекта от този клас.

И така, това, което заключаваме от горната дефиниция, е, че сме скрили променливите на членовете на данни в клас и също така сме посочили модификаторите за достъп, така че да не са достъпни за останалите класове.

По този начин капсулирането също е вид „скриване на данни“, въпреки че по-късно в урока ще видим, че капсулирането не е същото като скриването на данни.

капсулиране

Горната фигура представлява клас, който е единица за капсулиране, която обединява данните и методите, работещи с тези данни, в една единица.

Тъй като капсулирането основно се занимава с данни, то алтернативно се нарича „капсулиране на данни“.

Можем да визуализираме капсулирането като медицинска капсула. Както всички знаем, лекарството е затворено в медицинска капсула. По същия начин данните и методите са затворени в една единица в капсулиране.

По този начин капсулирането действа като защитен щит около данните и предотвратява неоторизиран достъп на данните от външния свят. С други думи, той защитава чувствителните данни на нашето приложение.

В Java има две стъпки за внедряване на капсулиране. Следват стъпките:

  • Използвайте модификатора на достъп ‘private’, за да декларирате променливите на класа.
  • За да осъществим достъп до тези променливи на частния член и да променим техните стойности, трябва да предоставим съответно методите public getter и setter.

Нека сега приложим примера за капсулиране в Java.

Пример за капсулиране на Java

//Student_Id and name bundled in a unit 'Student' => encapsulation class Student { private int Student_Id; private String name; //getters, setters for Student_Id and name fields. public int getId() { return Student_Id; } public void setId(int s_id) { this.Student_Id = s_id; } public String getname() { return name; } public void setname(String s_name) { this.name = s_name; } } class Main{ public static void main(String() args) { //create an object of Student class Student s=new Student(); //set fields values using setter methods s.setId (27); s.setname('Tom Lee'); //print values using getter methods System.out.println('Student Data:' + ' Student ID:' + s.getId() + ' Student Name:' + s.getname()); } }

Изход:

Резултат - Пример за капсулиране

В горната програма декларираме клас, който е единицата за капсулиране. Този клас Student обединява данните (Student_Id и име) и методите за четене и задаване на стойности за тези членове в една единица.

Обърнете внимание на модификаторите на достъп, свързани с полетата на членовете. И двете полета за членове са частни, така че да не са достъпни извън класа Student.

Предоставяме getters (getId и getname) за четене на стойностите на тези полета и методи за задаване (setId и setname) за задаване на стойности за тези методи. Това е единственият достъп, който имат и това също трябва да се направи с помощта на обекта на клас Student.

кое от следните предлага отдалечена програма, която изглежда и се чувства като локално приложение?

Методи за гетер и сетер

За да приложим капсулиране в Java, ние правим променливите на членовете на данните на класа като частни. Сега тези частни променливи не са достъпни за нищо извън класа, включително обекта на класа.

Това означава, че ако имаме клас ABC, както следва.

клас ABC {

частна възраст;

}

Нека създадем обект от клас ABC, както следва:

ABC abc = нов ABC ();

abc.age = 21; // грешка на компилатора

Така че в горния код достъпът до частната променлива с помощта на обекта на класа ще доведе до грешка в компилатора.

За да осъществим достъп до частните променливи и да прочетем техните стойности и да зададем някои нови стойности в тях, имаме нужда от някакъв начин да направим това. По този начин Java предоставя начин за достъп до частни променливи, използвайки методите getter и setter.

Getter и Setters са публични методи, които можем да използваме за създаване, модифициране, изтриване или просто преглед на стойностите на частните променливи.

Програмата по-долу е пример за методите Getter и Setter.

//Account class - private data members bundled with getters and setters class Account { //private data members private long acc_no; private String name,email; private float amount; //public getter and setter methods for each data member 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; } } public class Main { public static void main(String() args) { //create instance of Account class Account myAcc=new Account(); //set values for data members through setter methods myAcc.setAcc_no(775492842L); myAcc.setName('SoftwareTestingHelp.com'); myAcc.setEmail('sth_account@sth.com'); myAcc.setAmount(25000f); //read data member values through getter methods System.out.println('Account No:' + myAcc.getAcc_no()+' '+'Account Name:' + myAcc.getName()+' '+'Account holder email:' + myAcc.getEmail()+' ' + 'Amount in Account:' + myAcc.getAmount()); } }

Изход:

getter и setter методи - изход

Горната програма има клас Акаунт и има четири частни променливи, свързани с акаунта. Тъй като всички членове на данните са частни, ние предоставихме методите getter и setter за всяка от тези променливи.

въпроси за интервю за тестване на автоматизация и отговори за опитни

В основния метод четем и задаваме стойности за тези частни променливи, използвайки методите public getter и setter, достъпни през обекта на класа Account.

Скриване на данни в Java

Често използваме капсулиране и скриване на данни взаимозаменяемо. Но и двете не са еднакви. Java капсулирането се занимава с групиране на свързани данни в една единица, за да се осигури по-добро управление и сигурност на данните.

Скриването на данни от друга страна ограничава достъпа на члена на данните, като скрива подробностите за изпълнението. Въпреки че капсулирането не е точно скриване на данни, то ни предоставя начина за скриване на данни. Скриването на данни се постига с помощта на модификатори за достъп.

Java предоставя четири модификатора за достъп.

  • публично: Достъпен за всички.
  • частно: Достъпен само в рамките на класа.
  • защитен: Достъпна до съдържащия пакет и подкласовете.
  • по подразбиране: Достъпен в пакета.

Капсулирането обединява данните в една единица, така че по някакъв начин ги скрива. Освен това прави данните частни и по този начин е недостъпен за външния свят. За да направим данните частни, използваме модификатора за достъп private, който е концепция за скриване на данни.

В същото време само съответните подробности се предоставят на крайния потребител, без да се излагат подробности за изпълнението, което е дефиниция на абстракция. По този начин можем да разглеждаме капсулирането като комбинация от абстракция, както и скриване на данни.

Защо се нуждаем от капсулиране

Има различни причини защо капсулирането е от съществено значение в Java:

  • Инкапсулацията ни позволява да модифицираме кода или част от кода, без да се налага да променяме други функции или код.
  • Инкапсулацията контролира начина на достъп до данните.
  • Можем да модифицираме кода въз основа на изискванията, като използваме капсулиране.
  • Капсулирането прави нашите приложения по-опростени.

често задавани въпроси

В # 1) Защо капсулирането се използва в Java?

Отговор: Капсулирането в Java е най-полезно за скриване на данните. Или с други думи, да се реши за предоставения достъп до данни кой може да има достъп до тях и кой не.

В # 2) Какво представлява капсулирането в ООП?

Отговор: Капсулирането е един от важните стълбове на обектно-ориентирания програмен език и се занимава с обединяването на данни и методи, работещи с тези данни, в една единица. Например, клас в Java е капсулирана структура. Капсулирането също така се занимава с решения относно предоставянето на достъп до данни.

В # 3) Какво е предимството на капсулирането в Java?

Отговор: Основното предимство на капсулирането в Java е скриването на данни. Използвайки капсулиране, можем да позволим на програмиста да вземе решение относно достъпа до данни и методите, работещи с тези данни. Например, ако искаме дадена част от данните да е недостъпна за никого извън класа, тогава правим тези данни частни.

В # 4) Какво представлява процесът на капсулиране?

Отговор: Капсулирането е процес на събиране на данни от един формат или протокол (в мрежови термини) и превод или преформатиране в друг формат или протокол, така че данните да са достъпни в приложенията или мрежата и в същото време да бъдат защитени.

В # 5) Каква е последната стъпка в капсулирането на данни?

Отговор: Последната стъпка в капсулирането е промяната на потребителската информация в еквивалентни данни. След това тези данни се променят в сегменти, които допълнително се трансформират в пакети с данни. Пакетите данни се поставят в логическа рамка, която може да се прехвърля напред и назад в софтуерната среда

Заключение

Това завършва нашия урок за капсулиране в Java. Капсулирането е техника за обединяване на променливите на членове и методите, работещи върху тези членове на данни в една единица. Класът в Java е класически пример за капсулиране, тъй като обхваща данните и методите в една единица.

Java постига изпълнение на капсулиране, като прави всички членове на данните частни и след това предоставя методи за получаване и задаване, които са публични, за да можем да четем стойностите на частните променливи и да задаваме нови стойности за тези променливи.

=> Посетете тук за ексклузивната серия уроци за обучение по Java.

Препоръчително четене

^