oops concepts c object oriented programming concept tutorial
Овај водич објашњава концепте ООПС-а на језику Ц #. Можете научити о објектно оријентисаним принципима програмирања попут полиморфизма, инкапсулације, наслеђивања и апстракције:
Објектно оријентисано програмирање је програмски модел који ради на принципу који се окреће око објеката, а не акције или логике. Омогућава корисницима да креирају објекте на основу захтева, а затим креирају методе за рад на тим објектима.
Циљ објектно оријентисаног програмирања је рад на овим објектима да би се добио жељени резултат.
=> Овде истражите целу серију водича за обуку за Ц #
Ревидирајмо неке од концепата које смо научили у нашим ранијим водичима !!
Простор имена
Простор имена у Ц # је колекција класа. Пружа структуру како би једно име класе било одвојено од другог назива класе декларишући их у другом простору имена. Тако да се часови са истим именом не сукобљавају једни с другима.
Класа
Класа је нацрт типа података. То је заправо колекција предмета. Садржи објекте и дефиницију операције коју треба извршити над тим објектом.
Предмети
Објекти су инстанце класе.
У нашим претходним водичима већ смо детаљно сазнали о класи и објектима.
Шта ћете научити:
ООПС концепти у Ц #
Објектно оријентисано програмирање нуди неколико предности у односу на остале моделе програмирања, као што су:
- Прецизан и јасан модуларни приступ програмима нуди лако разумевање и одржавање.
- Класе и објекти створени у пројекту могу се користити у целом пројекту.
- Модуларни приступ омогућава различитим модулима да постоје независно, омогућавајући тако неколико различитих програмера да заједно раде на различитим модулима.
У овом упутству ћемо се више фокусирати на остале главне ООПС концепте:
- Капсулација
- Полиморфизам
- Наслеђивање
- Одвајање
Капсулација
Инкапсулација је објектно оријентисан концепт програмирања који омогућава програмерима да умотају податке и исечке кода унутар кућишта. Користећи програм енкапсулације, можете сакрити чланове једне класе од друге класе. То је као да окружите логичку ставку унутар пакета. Омогућава само релевантне информације доступне и видљиве споља и то само одређеним члановима.
Инкапсулација се спроводи коришћењем спецификатора приступа. Спецификатор приступа користи се за дефинисање видљивости и приступачности члана класе у Ц #.
Ц # садржи следеће спецификаторе приступа.
најбољи софтвер за сакривање ип адресе
- Јавно
- Приватни
- Заштићено
- Интерни
Спецификатори приступа дефинишу видљивост класе и њене вредности. Омогућава вам да податке учините видљивим за одређени део кода и сакријете их од другог дела. Најчешће коришћена видљивост је јавна и приватна.
Погледајмо их.
Јавно: Кључна реч публиц омогућава члановима да буду видљиви са било ког места у пројекту. Овај спецификатор приступа има најмање ограничење видљивости.
Приватни: Приватним члановима може приступити само члан из исте класе. Ово је једна од најограниченијих видљивости.
Заштићено: Заштићена приступачност омогућава члану приступ из класе и из друге класе која наслеђује ову класу.
Интерно: Интерно обезбеђује приступ унутар пројекта. Још једна слична унутрашња доступност је заштићена унутрашња. То омогућава исто што и интерно, а једина разлика је у томе што дете класа може наследити ову класу и доћи до њених чланова чак и из другог пројекта.
Полиморфизам
Полиморфизам је изведен из грчког речника, значи онај са много облика. Поли означава многе, а Морпх значи форме. Омогућава класи у Ц # да има више имплементација са истим именом.
Полиморфизам је у основи подељен на два дела:
- Полиморфизам компајлираног времена
- Полиморфизам времена извођења
# 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(); } }
У горњем примеру, исту методу смо два пута назвали „принт“ користећи различите параметре. У почетку прослеђујемо две целобројне вредности као параметре, затим смо проследили две низове као параметре. Постоје две методе „штампања“ са истим именом.
Када проследимо параметар са целобројним системом, он ће тражити методу која се зове „принт“ која прихвата два целобројна параметра, а извршиће је игноришући друге методе са истим именом.
У другом делу смо проследили параметар стринга. Поново ће систем тражити методу која прихвата два параметра низа. Дакле, на основу прослеђених параметара, прва метода ће додати две целине, а следећа ће спојити два низа.
# 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
Иако је класа Екецуте наследила све методе класе Програм, али када смо позвали методу принт која је присутна у обе класе, метода присутна у подређеној класи замениће методу из родитељске класе.
Динамички полиморфизам се користи за примену апстракције. Омогућава кориснику да креира апстрактну класу која се користи за пружање имплементације интерфејса када је наследи изведена класа. Апстрактна класа може садржати имена / потпис метода, а изведена класа може имати специјализованију дефиницију методе.
Наслеђивање
Наслеђивање је важан део концепта ООПС. У наследству дефинишемо класе родитеља и детета. Подређена класа може наследити све методе, објекте и својства родитељске класе. Дечји разред такође може имати своје методе и специфичну примену.
Родитељска класа је такође позната као основна класа, а подређена класа која наслеђује основну класу такође је позната као изведена класа.
Пример:
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(); } }
Овде имамо класу названу као програм који има један метод. Имамо другу класу Екецуте која наслеђује класу Програм. Класа Екецуте је изведена класа, а програм класе познат је као основна класа.
Сада, уместо да креирамо објектну инстанцу за програм класе, креирали смо инстанцу објекта за класу Екецуте. Коришћењем ове инстанце можемо приступити методи штампања из основне класе.
Дакле, излаз горњег кода биће:
Printing from class Program
Изведена класа не наслеђује само методе, она такође наслеђује готово све чланове класе, попут поља, својстава итд., У зависности од видљивости. Наслеђивање у Ц # не дозвољава употребу више наследстава, тј. Једна класа не може наследити из неколико различитих класа, међутим, једна класа може наследити другу класу која може наследити другу класу.
Одвајање
Апстракција је један од главних принципа објектно оријентисаног програмирања. Апстракција омогућава програмеру да свету прикаже само потребне детаље, док остале скрива. Апстракција се постиже у Ц # коришћењем класе Абстрацт и интерфејса.
Класа се може декларисати као апстрактна класа помоћу кључне речи „Абстрацт“. Класа Абстрацт у Ц # је увек основна класа у хијерархији. Оно што их чини другачијима од друге класе је што не могу да се примере. Апстрактну класу Ц # треба наследити.
Пример:
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
Ако га упоредите са нашим претходним примерима током наслеђивања или динамичког полиморфизма, тада ћете пронаћи сличности. Најпрепознатљивија разлика је употреба апстрактне кључне речи пре класе Ауто. У случају да желите да ово заобиђете или обезбедите сопствену имплементацију сличну оној коју смо радили у динамичком полиморфизму. Тада то можете постићи на следећи начин.
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
Изведена метода класе замењује метод основне класе. На овај начин можете створити другу изведену класу као што су Феррари, Порсцхе, БМВ итд., Са сопственим методама примене.
Ако пажљиво погледате, можете видети да наша метода описа у апстрактној класи не садржи никакву примену.
Зашто онда дефинишемо празне методе?
То је зато што класа Абстрацт даје потпис метода и обавезује поткласе да креирају имплементацију за све ове методе. Ово омогућава дељење основне класе, али истовремено задржава и проверу имплементације методе изведене класе.
Интерфејс
У Ц #, интерфејс је нацрт класе. Интерфејс је сличан апстрактној класи и користи се за постизање стопостотне апстракције. Све методе описане унутар интерфејса су подразумевано апстрактне. Она нема тело методе и не може се инстанцирати.
Интерфејс се углавном користи за постизање вишеструког наслеђивања и потпуне апстракције. Сав потпис методе декларисан унутар интерфејса треба да има имплементацију из класе или структуре која га имплементира.
Пример:
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
Овде смо креирали интерфејс Цар. Како интерфејс не може имати дефиницију методе, управо смо навели име методе и тип повратка у интерфејсу. Затим смо интерфејс Цар применили у другу класу Хиундаи. У имплементираној класи дали смо дефиницију метода дефинисаних унутар интерфејса.
Закључак
У концепту објектно оријентисаног програмирања, сваки део програма третира се као објекат. Класа је колекција сличних типова елемената, а објекат је инстанца класе.
Инкапсулација у Ц # омогућава кориснику да утврди видљивост класе и њених чланова. Полиморфизам омогућава да методе имају исто име, али са различитим параметрима унутар исте класе или са истим параметром у другој класи.
Наслеђивање је када подређена класа која је такође позната и као изведена класа наслеђује сва својства укључујући методе, објекте, поља итд. Родитељске класе која је такође позната и као основна класа. Апстракција омогућава програму да прикаже само потпис док скрива детаље о имплементацији.
Консолидовани програм
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'; } }
=> Овде истражите целу серију водича за обуку за Ц #
Препоручено читање
- ООП Јава: Увод у објектно оријентисано програмирање на Јави
- Објектно оријентисано програмирање на језику Ц ++
- Водич за Уник цеви: Цеви у програмирању за Уник
- Водич за Питхон ДатеТиме са примерима
- Спремиште објеката у КТП-у - Туториал # 22
- Питхон ООПс концепти (класе Питхон, објекти и наслеђивање)
- КТП водич # 7 - КТП-ова парадигма идентификације објеката - Како КТП јединствено идентификује објекте?
- Научите напредне концепте скриптирања Гроови за СоапУИ - Водич за бр. 9 за СоапУИ