Принципи на ООП

здрасти В днешния урок ще говорим за принципите на обектно-ориентираното програмиране. Чудor ли сте се някога защо Java е проектирана точно така, Howто е? Искам да кажа, че декларирате класове и създавате обекти въз основа на класове, класовете имат методи и т.н. Но защо езикът е структуриран така, че програмите да се състоят от класове и обекти, а не от нещо друго? Защо беше измислено понятието „обект“ и поставено на преден план? Всички езици ли са проектирани по този начин? Ако не, Howви предимства дава на Java? Както можете да видите, има много въпроси :) Нека се опитаме да отговорим на всеки от тях в днешния урок.

Какво е обектно-ориентирано програмиране (ООП)?

Разбира се, Java не е съставена от обекти и класове само за забавление. Те не са прищявка на създателите на Java и дори не са тяхно изобретение. Има много други езици, базирани на обекти. Първият такъв език се нарича "Simula". Изобретен е през 60-те години на миналия век в Норвегия. Нещо повече, понятията "клас" и "метод" се появиха в Simula. По стандартите за разработка на софтуер "Simula" изглежда като древен език, но всеки може да види "семейната му прorка" с Java. Вероятно можете лесно да прочетете codeа, написан на този език, и да обясните накратко Howво прави :)

Begin
	Class Rectangle (Width, Height); Real Width, Height;
			           
	 Begin
	    Real Area, Perimeter;  
	 
	    Procedure Update;      
	    Begin
	      Area := Width * Height;
              OutText("Rectangle is updating, Area = "); OutFix(Area,2,8); OutImage;
	      Perimeter := 2*(Width + Height);
              OutText("Rectangle is updating, Perimeter = "); OutFix(Perimeter,2,8); OutImage;
	    End of Update;
	 
	    Update;               
	    OutText("Rectangle created: "); OutFix(Width,2,6);
	    OutFix(Height,2,6); OutImage;
	 End of Rectangle;

       Rectangle Class ColouredRectangle (Color); Text Color;
			           
	Begin   	  
	    OutText("ColouredRectangle created, color = "); OutText(Color);
	    OutImage;
        End of ColouredRectangle;

 
      	 Ref(Rectangle) Cr;            
	 Cr :- New ColouredRectangle(10, 20, "Green"); 
End;

Този примерен code е взет от „Simula – 50 години OOP“ от Weekly-geekly. Както можете да видите, Java не е толкова различна от своя дядо :) Това се дължи на факта, че появата на Simula бележи раждането на нова концепция: обектно-ориентирано програмиране. Уикипедия дефинира ООП по следния начин: „Обектно-ориентираното програмиране (ООП) е програмна парадигма, базирана на концепцията за „обекти“, които могат да съдържат данни под формата на полета (често известни като атрибути) и code във формата на proceduresи (често известни като методи)." Според мен това е наистина добро определение. Не беше много отдавна, когато започнахте да учите Java, но това определение вероятно не съдържа думи, които не знаете :) Днес ООП е най-разпространената методология за програмиране. В допълнение към Java, Принципите на ООП се използват в много популярни езици, за които може би сте чували. Например C++ (активно използван в разработката на игри), Objective-C и Swift (използван за писане на програми за устройства на Apple), Python (най-популярен в машинното обучение), PHP (един от най-популярните езици за уеб разработка), JavaScript ( по-лесно е да се каже за Howво не се използва) и много други. И така, Howви са принципите на ООП? Ще ви разкажем подробно. Howви са принципите на ООП? Ще ви разкажем подробно. Howви са принципите на ООП? Ще ви разкажем подробно.

Принципи на ООП

Това са основата на основата. 4-те основни характеристики, които заедно формират парадигмата на обектно-ориентираното програмиране. Разбирането им е от съществено meaning, за да станете успешен програмист.

Принцип 1. Наследяване

Добра новина: вече знаете някои от принципите на ООП! :) Вече се сблъскахме с наследяването няколко пъти в уроците и успяхме да го използваме. Наследяването е механизъм, който ви позволява да опишете нов клас въз основа на съществуващ (родителски) клас. По този начин новият клас заема свойствата и функционалността на родителския клас. За Howво е наследството и Howви предимства дава? Преди всичко повторно използване на codeа. Полетата и методите, декларирани в родителските класове, могат да се използват в наследствените класове. Ако всички видове коли имат 10 общи полета и 5 идентични метода, просто трябва да ги преместите в Autoродителски клас. Можете да ги използвате в класове потомци без ниHowви проблеми. Солидни предимства: Howто количествени (по-малко code), така и качествени (класовете стават много по-прости). Освен това наследяването е много гъвкаво — можете да добавите отделна функционалност за запис, която липсва на наследниците (някои полета or поведение, които са специфични за определен клас). Като цяло, Howто и в реалния живот, всички ние донякъде прorчаме на родителите си, но и по няHowъв начин се различаваме от тях :)

Принцип 2. Абстракция

Това е много прост принцип. Абстракцията означава да се идентифицират основните, най-значимите характеристики на нещо, като същевременно се отхвърля всичко второстепенно и незначително. Няма нужда да преоткривате колелото. Нека си припомним пример от стар урок за класове. Да предположим, че създаваме система за архивиране на служителите на компанията. За да създадем обекти "служител", ние написахме клас Служител . Какви характеристики са важни, за да ги опишем във фирмената система за архивиране? Име, дата на раждане, SSN и ID на служител. Но е малко вероятно да имаме нужда от височината, цвета на очите or косата на служителя за този тип записи. Компанията няма нужда от такава информация за служител. И така, в класа Employee декларираме следните променливи:, int age , int socialSecurityNumber и int employeeId . И ние абстрахираме ненужната информация като цвета на очите. Ако обаче правим система за архивиране на агенция за модели, ситуацията се променя драматично. Височината, цветът на очите и косата на модела са важни характеристики, но нейният SSN е абсолютно без meaning за нас. И така, в класа Model създаваме следните променливи: String height , String hair , String eyes .

Принцип 3. Капсулиране

Вече се сблъскахме с това. В Java капсулирането означава ограничаване на възможността за четене и промяна на данни. Както можете да видите, терминът се основава на думата "капсула". Ще използваме „капсула“, за да скрием някои важни данни, които не искаме други да променят. Ето един прост пример от реалния живот. Имате име и фамorя. Всичките ви приятели ги знаят. Но те нямат възможност да променят вашето име or фамorя. Можем да кажем, че процесът за това е „капсулиран“ от съдебната система: можете да промените фамилното си име само чрез съдебния служител и само вие можете да го направите. Други "потребители" имат достъп "само за четене" до вашето име и фамorя :) Друг показателен пример са парите в брой, съхранявани у дома. Не е добра идея да го оставяте на видно място в средата на стаята си. Всеки "потребител" (човек, който идва във вашия дом) ще може да промени сумата на вашите пари, т.е. може да вземе вашите пари. Би било по-добре да го капсулирате в сейф. Тогава достъпът ще бъде достъпен само за вас и само чрез използване на специален code. Очевидни примери за капсулиране, с които вече сте работor, са модификатори за достъп (частен, публичен и т.н.), Howто и сетери и гетери. Ако не капсулиратеПолето за възраст на Cat class , тогава всеки може да напише:

Cat.age = -1000;

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

Принцип 4. Полиморфизъм

Полиморфизмът е способността да се работи с няколко типа, сякаш са от един и същи тип. Освен това поведението на обектите ще бъде различно в зависимост от вида им. Звучи ли сложно? Нека го осмислим веднага. Вземете най-простия пример: животни. Създайте клас Animal с един метод speak() и два подкласа — Cat и Dog .

public class Animal {

   public void speak() {
      
       System.out.println("Hello!");
   }
}

public class Dog extends Animal {
  
   @Override
   public void speak() {
       System.out.println ("Woof-woof!");
   }
}

public class Cat extends Animal {

   @Override
   public void speak() {
       System.out.println("Meow!");
   }
}

Сега ще се опитаме да декларираме референтна променлива Animal и да й присвоим обект Dog .

public class Main {

   public static void main(String[] args) {

       Animal dog = new Dog();
       dog.speak();
   }
}

Какъв метод мислите, че ще бъде извикан? Animal.speak() or Dog.speak() ? Методът в класа Dog ще се нарича: Woof-woof! Създадохме препратка към животно , но обектът се държи като куче . Ако е необходимо, може да се държи като котка, кон or друго животно. Важното е да присвоите конкретен подклас на общата референтна променлива Animal . Това има смисъл, защото всички кучета са животни. Това имахме предвид, когато казахме, че "поведението на обектите ще бъде различно в зависимост от техния тип." Ако създадохме обект Cat ...

public static void main(String[] args) {

   Animal cat = new Cat();
   cat.speak();
}

методът speak () ще покаже "Мяу!" Но Howво имаме предвид под „способността да работим с няколко типа, сякаш са от един и същи тип“? Това също е доста лесно. Нека си представим, че създаваме бръснарница за животни. Нашата бръснарница трябва да може да подстриже всяко животно, затова създаваме метод trim() с параметър Animal (животното, което се подстригва).

public class AnimalBarbershop {

   public void trim(Animal animal) {

       System.out.println("The haircut is done!"); 
   }
}

И сега можем да предаваме обекти Cat и Dog на метода trim() !

public static void main(String[] args) {

   Cat cat = new Cat();
   Dog dog = new Dog();

   AnimalBarbershop barbershop = new AnimalBarbershop();

   barbershop.trim(cat);
   barbershop.trim(dog);
}

И ето ясният пример: класът AnimalBarbershop работи с типовете Котка и Куче , сякаш са от един и същи тип. В същото време Котката и Кучето имат различно поведение: всеки говори по различен начин.

Защо се нуждаем от ООП?

Защо ООП изобщо възникна като нова концепция за програмиране? Програмистите имаха работещи инструменти, като proceduresни езици. Какво ги е подтикнало да измислят нещо принципно ново? Преди всичко сложността на задачите, пред които са изпequalsи. Ако преди 60 години задачата на програмиста беше нещо като „оцени няHowъв математически израз“, сега може да бъде нещо като „приложи 7 различни края за играта STALKER, в зависимост от комбинациите от решенията на играча, напequalsи в точки A, B, C, DE , и F в играта." Както можете да видите, задачите очевидно са се усложнor през последните десетилетия. И в резултат на това типовете данни са станали по-сложни. Това е още една причина да се появи ООП. Един математически израз може да бъде оценен лесно с помощта на обикновени примитиви. Тук не са необходими предмети. Но задачата с края на играта би била трудна дори за описание без използване на персонализирани класове. Въпреки това е доста лесно да се опише с помощта на класове и обекти. Очевидно ще ни трябват няколко класа: Game, Stalker, Ending, PlayerDecision, GameEvent и т.н. С други думи, дори без да сме започнали да решаваме проблема, лесно можем да „начертаем“ решение в главата си. Нарастващата сложност на задачите принуди програмистите да ги разделят на части. Но това не беше толкова лесно да се направи в proceduresното програмиране. И доста често програмата беше като дърво с много клони, представящи всички възможни пътища за изпълнение. В зависимост от определени условия се изпълняваше един or друг клон на програмата. За малки програми това беше удобно, но беше много трудно да се раздели голям проблем на части. Това беше още една причина за появата на ООП. Тази парадигма даде възможност на програмистите да разделят програма на куп "модули" (класове), всеки от които изпълнява своята част от работата. Като си взаимодействат помежду си, всички обекти изпълняват работата на нашата програма. Освен това можем да използваме повторно нашия code другаде в програмата, което също спестява много време.