Капсулация в Java

здрасти Ще посветим днешния урок на капсулирането в Java и ще започнем с примери веднага:) Тук имате обикновена машина за дозиране на сода . Имам един въпрос към вас: How работи? Опитайте се да дадете подробен отговор: Откъде идва содата? Как се поддържа вътрешната температура? Къде се съхранява ледът? Как машината знае кой сироп да добави? Вероятно нямате отговори на тези въпроси. Добре, може би не всеки използва тези машини. Те не са толкова популярни в момента. Нека опитаме друг пример. Нещо, което определено използвате много пъти всеки ден. О, имам идея! Кажете ми How търсачката Googleвърши работа. Как точно търси информация за думите, които въвеждате? Защо тези резултати са на върха, а не други? Въпреки че използвате Google всеки ден, вероятно не знаете. Но това няма meaning. В крайна сметка това не е нещо, което трябва да знаете. Можете да използвате търсачка, без да мислите How точно работи. Можете да си купите сода от машина, без да знаете How е напequalsа. Можете да карате кола, без да се задълбочавате в работата на двигателя с вътрешно горене и дори без да знаете гимназиална физика. Всичко това е възможно благодарение на един от основните принципи на обектно-ориентираното програмиране: капсулиране. Четейки различни статии по темата, сигурно сте срещали две широко разпространени концепции за програмиране: капсулиране и скриване на информация. Както се случва, различни хора разбират думата " капсулиране“, за да означава различни неща. Ще дешифрираме и двата термина, за да имате пълно разбиране. В програмирането, първоначалното meaning накапсулирането комбинира данни и методи за работа с тези данни в един пакет ("капсула"). В Java капсулиращият пакет е класът . Класът съдържа Howто данни (полета), така и методи за работа с тези данни. Това може да изглежда очевидно за вас, но всичко е подредено по различен начин в други парадигми на програмиране. Например във функционалното програмиране данните са строго разделени от операциите с данни. В обектно-ориентираното програмиране (ООП) програмите се състоят от капсули (класове), състоящи се от данни и функции за работа с данни.

Сега нека поговорим за скриването на информация

Как използваме всяHowви сложни механизми, без да разбираме How са изградени or How работят? Просто е: техните създатели предоставиха прости и удобни интерфейси. На машината за газирани напитки интерфейсът е бутоните на предния панел. Един бутон ви позволява да изберете размера на чашата. С втори бутон избирате сиропа. Трета е отговорна за добавянето на лед. И това е всичко, което трябва да направите. Няма meaning How изглежда машината отвътре. Важното е, че е проектиран така, че потребителят да получава сода чрез натискане на три бутона. Същото важи и за кола. Няма meaning Howво се случва вътре. Важното е, че при натискане на десния педал колата се движи напред, а при натискане на левия колата намалява. Това е същността на криенето на информация. Цялата програма' 'вътрешностите' са скрити от потребителя. Такава информация е излишна or ненужна за потребителя. Потребителят се нуждае от краен резултат, а не от вътрешен процес. За пример, нека да разгледамеКлас на превозното средство :

public class Vehicle {

   public void gas() {

       /* Some complicated things happen inside a car.
       As a result, it moves forward */
   }

   public void brake() {

       /* Some complicated things happen inside a car.
       As a result, it slows down */
   }

   public static void main(String[] args) {

       Vehicle vehicle = new Vehicle();

       // How everything looks to the user

       // Press one pedal, the car moves
       vehicle.gas();

       // Press the other pedal, the car brakes
       vehicle.brake();
   }
}

Ето How внедряването е скрито в Java програма. Точно Howто в реалния живот: на потребителя се предоставя интерфейс (методи). В една програма, ако имате нужда от кола, за да извършите действие, просто извиквате желания метод. Това, което се случва вътре в тези методи, е излишно. Важното е всичко да работи Howто трябва. Тук говорихме за скриване на изпълнението. Java също има скриване на данни. Писахме за това в урока за гетери и сетери, но едно напомняне няма да навреди. Например, имаме клас Cat :

public class Cat {

   public String name;
   public int age;
   public int weight;

   public Cat(String name, int age, int weight) {
       this.name = name;
       this.age = age;
       this.weight = weight;
   }

   public Cat() {
   }

   public void sayMeow() {
       System.out.println("Meow!");
   }


}

Може би си спомняте от минал урок Howъв е проблемът с този клас? Ако не, да си припомним. Проблемът е, че неговите данни (полета) са отворени за всички. Друг програмист може лесно да създаде безименна котка с тегло 0 и възраст -1000 години:

public static void main(String[] args) {

   Cat cat = new Cat();
   cat.name = "";
   cat.age = -1000;
   cat.weight = 0;

}

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

1. модификатори за достъп ( private, protected, package default );
2. гетери и сетери.

Използваме ги, за да проверим дали някой се опитва да даде на котката отрицателна възраст. Както казахме по-рано, авторите на различни статии за капсулиране всъщност имат предвид капсулиране (комбиниране на данни и методи) or скриване на информация, or и двете. Java има и двата механизма (това не е непременно така в други ООП езици), така че последната опция е най-правилната.

Капсулирането ни дава няколко важни предимства:

1. Мониторинг на правилното състояние на обекта. Дадохме примери за това по-горе: благодарение на сетера и частния модификатор, ние защитихме нашата програма срещу котки с тегло 0.


2. Удобен за потребителя интерфейс. Оставяме само методите, изложени на потребителя. Потребителят просто трябва да им се обади, за да получи резултат. И няма ниHowва нужда да се задълбочаваме в подробности за това How работят.


3. Промените в codeа не засягат потребителите. Ние правим всички промени вътре в методите. Това не засяга потребителите: те са написали vehicle.gas() , за да подадат газ, и това е, което ще продължат да правят. Фактът, че променихме нещо в метода gas() остава невидим: Howто преди, те просто получават необходимия резултат.