Меню

OOPS концепции в C #: Урок за концепция за обектно ориентирано програмиране

  • Основен
  • Други
  • OOPS концепции в C #: Урок за концепция за обектно ориентирано програмиране

oops concepts c object oriented programming concept tutorial

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

Този урок обяснява концепциите на OOPS в C #. Можете да научите за обектно-ориентирани принципи на програмиране като полиморфизъм, капсулиране, наследяване и абстракция:

Обектно-ориентираното програмиране е програмен модел, който работи на принцип, който се върти около обекти, а не действие или логика. Позволява на потребителите да създават обекти въз основа на изискването и след това да създават методи за работа с тези обекти.

Работата върху тези обекти за получаване на желания резултат е целта на обектно-ориентираното програмиране.

=> Разгледайте цялата поредица от уроци за обучение на C # тук

OOPS концепции в C #

Нека преразгледаме някои от концепциите, които научихме в предишните ни уроци !!

Пространство от имена

Пространството от имена в C # е колекция от класове. Той осигурява структура, която да държи едно име на клас отделно от друго име на клас, като ги декларира в различно пространство от имена. За да не противоречат класовете със същото име.

Клас

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

Обекти

Обектите са екземплярите на класа.

В предишните ни уроци вече научихме подробно за клас и обекти.

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

OOPS концепции в C #

Обектно-ориентираното програмиране предлага няколко предимства пред останалите модели на програмиране като:

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

В този урок ще се съсредоточим повече върху други основни концепции на OOPS:

  1. Капсулиране
  2. Полиморфизъм
  3. Наследяване
  4. Абстракция

Капсулиране

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

Капсулирането се осъществява чрез използване на спецификатори за достъп. Access Specifier се използва за определяне на видимостта и достъпността на члена на класа в C #.

C # съдържа следните спецификатори за достъп.

най-добрият софтуер за скриване на ip адрес
  • Публично
  • Частен
  • Защитена
  • Вътрешен

Спецификаторите за достъп определят видимостта на класа и неговите стойности. Тя ви позволява да направите данните видими за определена част от кода и да ги скриете от друга част. Най-често използваната видимост е публична и частна.

Нека ги разгледаме.

Публично: Публичната ключова дума позволява на членовете да бъдат видими от всяко място в проекта. Този спецификатор за достъп има най-малкото ограничение за видимост.

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

Защитени: Защитената достъпност позволява достъп до члена от клас и от друг клас, който наследява този клас.

Вътрешен: Internal осигурява достъпност в рамките на проекта. Друга подобна вътрешна достъпност е защитена вътрешна. Това позволява същото като вътрешния и единствената разлика е, че детски клас може да наследи този клас и да достигне до неговите членове дори от друг проект.

Полиморфизъм

Полиморфизмът произлиза от гръцкия речник, той означава такъв с много форми. Poly означава много, а Morph означава форми. Тя позволява на класа в C # да има множество реализации с едно и също име.

Полиморфизмът се разделя на две части:

  1. Полиморфизъм по време на компилация
  2. Полиморфизъм на времето за изпълнение

# 1) Статичен или компилиран времеви полиморфизъм

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

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

Пример:

class Program { void print(int i, int j) { Console.WriteLine('Printing int: {0}', (i+j) ); } void print(string a, string b) { Console.WriteLine('Printing String: ' , (a+b)); } static void Main(string() args) { Program prog = new Program(); // Call print for sum of integers prog.print(5, 6); // Call to concatenate strings prog.print('Hello','World'); Console.ReadKey(); } }

В горния пример ние нарекохме един и същ метод „print“ два пъти, използвайки различни параметри. Първоначално предаваме две цели числа като параметри, след това сме предали два низа като параметри. Има два метода за печат със същото име.

Когато предадем параметър със системата с цели числа, той ще търси метода, наречен „print“, който приема два целочислени параметъра, и ще изпълни този, като пренебрегне други методи със същото име.

Във втората част предадохме параметъра низ. Отново системата ще търси метода, който приема два низови параметъра. Следователно, въз основа на предадените параметри, първият метод ще добави две цели числа, а следващият ще обедини два низа.

# 2) Динамичен полиморфизъм или полиморфизъм по време на изпълнение

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

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

Пример:

class Program { public void print() { Console.WriteLine('Printing from class Program'); } } class Execute : Program { public void print() { Console.WriteLine('Printing from class Execute'); } public static void Main(string() args) { Execute exe = new Execute(); exe.print(); Console.ReadLine(); } }

Ако стартираме горната програма, ще получим следния изход:

Printing from class Execute

Въпреки че класът Execute е наследил всички методи на класа Program, но когато извикаме метода print, който присъства и в двата класа, методът, присъстващ в дъщерния клас, ще замени метода от родителския клас.

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

Наследяване

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

Родителският клас е известен също като основен клас, а дъщерният клас, който наследява базовия клас, също е известен като производен клас.

Пример:

class Program { public void print() { Console.WriteLine('Printing from class Program'); } } class Execute : Program { public static void Main(string() args) { Execute exe = new Execute(); exe.print(); Console.ReadLine(); } }

Тук имаме клас, наречен като програма, която има един метод. Имаме друг клас Execute, който наследява класа Program. Класът Execute е производният клас и програмата на класа е известна като основен клас.

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

И така, изходът на горния код ще бъде:

Printing from class Program

Полученият клас не само наследява методи, но и наследява почти всички членове на класа като полета, свойства и т.н. в зависимост от видимостта. Наследяването в C # не позволява използването на множество наследства, т.е. един клас не може да наследява от няколко различни класа, но един клас може да наследи от друг клас, който може да наследи от различен клас.

Абстракция

Абстракцията е един от основните принципи на обектно-ориентираното програмиране. Абстракцията позволява на програмиста да показва на света само необходимите детайли, докато скрива останалите. Абстракцията се постига в C #, като се използва класът и интерфейсът Abstract.

Класът може да бъде деклариран като абстрактен клас с помощта на ключовата дума „Abstract“. Абстрактният клас в C # винаги е базовият клас в йерархията. Това, което ги прави различни от другия клас, е, че те не могат да бъдат инстанцирани. Абстрактният клас C # трябва да бъде наследен.

Пример:

class Program { static void Main(string() args) { Hyundai hyn = new Hyundai(); String descp = hyn.Describe(); Console.WriteLine(descp); Console.ReadKey(); } } abstract class Car { public void Describe() { return 'Description of the car'; } } class Hyundai : Car { }

Резултатът от следното е:

Description of the car

Ако го сравните с предишните ни примери по време на наследяване или динамичен полиморфизъм, тогава ще откриете приликите. Най-разпознаваемата разлика е използването на абстрактна ключова дума преди класа Car. В случай, че искате да замените това или да предоставите собствено изпълнение, подобно на това, което направихме в динамичния полиморфизъм. Тогава можете да постигнете това чрез следното.

class Program { static void Main(string() args) { Hyundai hyn = new Hyundai(); String descp = hyn.Describe(); Console.WriteLine(descp); Console.ReadKey(); } } abstract class Car { public virtual string Describe() { return 'Description of the car'; } } class Hyundai : Car { public override string Describe() { return 'Description of the car is now Hyundai'; } }

Така че, ако изпълните този код сега, той ще даде следния изход:

Description of the car is now Hyundai

Методът на производен клас замества метода на базовия клас. По този начин можете да създадете различен производен клас като Ferrari, Porsche, BMW и др. Със собствени методи за изпълнение.

Ако се вгледате внимателно, можете да видите, че нашият метод за описание в абстрактния клас не съдържа никаква реализация.

Тогава, защо дефинираме празни методи?

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

Интерфейс

В C # интерфейсът е план на клас. Интерфейсът е подобен на абстрактния клас и се използва за постигане на сто процента абстракция. Всички методи, описани вътре в интерфейса, са абстрактни по подразбиране. Той няма тяло на метода и не може да бъде създаден.

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

Пример:

class Program { static void Main(string() args) { Hyundai hyn = new Hyundai(); String descp = hyn.Describe(); Console.WriteLine(descp); Console.ReadKey(); } } interface Car { string Describe(); } class Hyundai : Car { public string Describe() { return 'Description of the car is now Hyundai'; } }

Резултатът от горния код ще бъде:

Description of the car is now Hyundai

Тук създадохме интерфейс Car. Тъй като интерфейсът не може да има дефиниция на метод, току-що сме предоставили името на метода и типа на връщане в интерфейса. След това внедрихме интерфейса Car в друг клас Hyundai. В внедрения клас предоставихме дефиницията за методите, дефинирани вътре в интерфейса.

Заключение

В концепцията за обектно-ориентирано програмиране всяка част от програмата се третира като обект. Class е колекция от подобни типове елементи, а обектът е екземпляр на класа.

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

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

Консолидирана програма

class Program { void print(int i, int j) { Console.WriteLine('Printing int: {0}', (i + j)); } void print(string a, string b) { Console.WriteLine('Printing String '+ a + b); } static void Main(string() args) { Program prog = new Program(); // Call print for sum of integers prog.print(5, 6); // Call to concatenate strings prog.print('Hello', 'World'); Hyundai hyn = new Hyundai(); String descp = hyn.Describe(); Console.WriteLine(descp); Console.ReadKey(); } } abstract class Car { public virtual string Describe() { return 'Description of the car'; } } class Hyundai : Car { public override string Describe() { return 'Description of the car is now Hyundai'; } }

=> Разгледайте цялата поредица от уроци за обучение на C # тук

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

^