Meny

OOPS Concepts In C #: Object Oriented Programming Concept Tutorial

  • Huvud
  • Övrig
  • OOPS Concepts In C #: Object Oriented Programming Concept Tutorial

oops concepts c object oriented programming concept tutorial

Prova Vårt Instrument För Att Eliminera Problem

Denna handledning förklarar OOPS-begreppen i C #. Du kan lära dig om objektorienterade programmeringsprinciper som polymorfism, inkapsling, arv och abstraktion:

Objektorienterad programmering är en programmeringsmodell som fungerar på en princip som kretsar kring objekt snarare än handling eller logik. Det gör att användarna kan skapa objekt baserat på kravet och sedan skapa metoder för att hantera dessa objekt.

Att arbeta med dessa objekt för att uppnå önskat resultat är målet för objektorienterad programmering.

=> Utforska hela serien av C # -träningsövningar här

OOPS-begrepp i C #

Låt oss se över några av de begrepp som vi lärde oss i våra tidigare självstudier !!

Namnområde

Ett namnområde i C # är en samling klasser. Det ger en struktur för att hålla ett klassnamn åtskilt från ett annat klassnamn genom att förklara dem i ett annat namnområde. Så att klasserna med samma namn inte strider mot varandra.

Klass

En klass är en ritning av en datatyp. Det är faktiskt en samling objekt. Den innehåller objekt och definitionen för operationen som måste utföras på det objektet.

Föremål

Objekt är förekomsten av klassen.

I våra tidigare handledning har vi redan lärt oss om klass och objekt i detalj.

Vad du kommer att lära dig:

OOPS-begrepp i C #

Objektorienterad programmering erbjuder flera fördelar jämfört med andra programmeringsmodeller som:

  1. Det exakta och tydliga modulära tillvägagångssättet för program ger enkel förståelse och underhåll.
  2. Klasser och objekt som skapats i projektet kan användas över hela projektet.
  3. Det modulära tillvägagångssättet gör att olika moduler kan existera oberoende, vilket gör att flera olika utvecklare kan arbeta på olika moduler tillsammans.

I denna handledning kommer vi att fokusera mer på andra viktiga OOPS-koncept:

  1. Inkapsling
  2. Polymorfism
  3. Arv
  4. Abstraktion

Inkapsling

Inkapsling är ett objektorienterat programmeringskoncept som gör det möjligt för programmerare att slå in data och kodavsnitt inuti ett hölje. Genom att använda inkapslingsprogrammet kan du dölja medlemmarna i en klass från en annan klass. Det är som att omsluta ett logiskt objekt i ett paket. Det tillåter endast relevant information som är tillgänglig och synlig utanför och också för specifika medlemmar.

Inkapsling implementeras med hjälp av åtkomstspecifikatorer. Access Specifier används för att definiera klassmedlemmens synlighet och tillgänglighet i C #.

C # innehåller följande åtkomstspecifikationer.

programvara som är installerad på en dator och används för att hantera virtuella maskiner
  • offentlig
  • Privat
  • Skyddade
  • Inre

Åtkomstspecifikatorerna definierar klassens synlighet och dess värden. Det låter dig göra data synliga för en viss del av koden och dölja den från en annan del. Den vanligaste synligheten är offentlig och privat.

Låt oss ta en titt på dem.

Offentlig: Det offentliga nyckelordet gör det möjligt för medlemmarna att vara synliga var som helst i projektet. Denna åtkomstspecifikator har minst synlighetsbegränsning.

Privat: De privata medlemmarna kan endast nås av medlemmen inom samma klass. Detta har en av de mest begränsade synligheten.

Skyddade: Med skyddad tillgänglighet kan medlemmen nås inifrån klassen och från en annan klass som ärver den här klassen.

Inre: Intern ger tillgänglighet inifrån projektet. En annan liknande intern tillgänglighet är skyddad intern. Detta tillåter samma som den interna och den enda skillnaden är att en barnklass kan ärva denna klass och nå sina medlemmar även från ett annat projekt.

Polymorfism

Polymorfism härrör från den grekiska ordboken, det betyder en med många former. Poly står för många och Morph betyder former. Det gör att klassen i C # kan ha flera implementeringar med samma namn.

Polymorfism är i grunden uppdelad i två delar:

  1. Sammanställningstid polymorfism
  2. Körtidspolymorfism

# 1) Statisk eller kompileringstidspolymorfism

Kompileringstidspolymorfism kallas också statisk polymorfism. Metodöverbelastning är ett av sätten på vilket polymorfism med kompileringstid uppnås. Det är känt som sammanställningstidspolymorfism eftersom metoden som kallar beslut fattas vid tidpunkten för sammanställningen.

Det uppnås genom att hålla metodnamnet detsamma men skicka olika uppsättningar parametrar. Vid metodöverbelastning kontrollerar systemet först den använda parametern och baserat på den uppsättning parametrar som den beslutar att anropa lämplig metod.

Exempel:

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(); } }

I exemplet ovan har vi kallat samma metod 'skriva ut' två gånger med olika parametrar. Först skickar vi två heltal som parametrar, sedan har vi skickat två strängar som parametrar. Det finns två 'utskriftsmetoder' med samma namn.

När vi skickar en parameter med heltalssystemet, kommer den att leta efter metoden som heter 'skriv ut' som accepterar två heltalsparametrar och den kommer att utföra att ignorera andra metoder med samma namn.

I den andra delen passerade vi strängparametern. Återigen kommer systemet att leta efter metoden som accepterar två strängparametrar. Följaktligen, baserat på parametrarna som skickats, kommer den första metoden att lägga till två heltal och nästa kommer att sammanfoga två strängar.

# 2) Dynamisk polymorfism eller Runtime-polymorfism

Runtime-polymorfism eller dynamisk polymorfism uppstår när både metodnamn och metodsignatur har samma namn och parametrar. Metodöverstyrning är ett exempel på dynamisk polymorfism. Det tillåter användaren att skapa en abstrakt klass med delvis gränssnittsimplementering.

Åsidosättande av metod uppnås med hjälp av arv. För att åstadkomma metod bör både basklassen och den härledda klassen ha samma namn och parameter. Under kompileringstiden kan kompilatorn inte känna igen den åsidosättande metoden, vilket gör att det inte ger något fel. Beslutet att köra en metod tas under körning.

Exempel:

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(); } }

Om vi ​​kör programmet ovan får vi följande resultat:

Printing from class Execute

Även om klassen Execute har ärvt alla metoder i klassprogrammet, men när vi kallade metodutskriften som finns i båda klasserna, kommer metoden som finns i underklassen att åsidosätta metoden från moderklassen.

Dynamisk polymorfism används för att implementera abstraktion. Det tillåter användaren att skapa en abstrakt klass som används för att tillhandahålla en implementering för ett gränssnitt när det ärvs av en härledd klass. Abstraktklassen kan innehålla metodernas namn / signatur och den härledda klassen kan ha en mer specialiserad definition för metoden.

Arv

Arv är en viktig del av OOPS-konceptet. I arv definierar vi föräldrar och barnklasser. Barnklassen kan ärva alla metoder, objekt och egenskaper hos moderklassen. En barnklass kan också ha sina egna metoder och specifika genomförande.

Föräldraklassen är också känd som en basklass och barnklassen som ärver basklassen kallas också härledd klass.

Exempel:

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(); } }

Här har vi en klass som heter ett program som har en metod. Vi har en annan klasskörning som ärver klassprogrammet. Klassen Execute är den härledda klassen och klassprogrammet kallas basklassen.

Nu, istället för att skapa en objektinstans för klassprogrammet, har vi skapat en objektinstans för klass Execute. Med denna instans kan vi komma åt utskriftsmetoden från basklassen.

Så resultatet av ovanstående kod kommer att vara:

Printing from class Program

Den härledda klassen ärver inte bara metoder utan ärver nästan alla klassmedlemmar som fält, egenskaper etc. beroende på synligheten. Arv i C # tillåter inte användning av flera arv, dvs. en klass kan inte ärva från flera olika klasser, men en klass kan ärva från en annan klass som kan ärva från en annan klass.

Abstraktion

Abstraktion är en av de viktigaste principerna för objektorienterad programmering. Abstraktion gör det möjligt för programmeraren att endast visa nödvändiga detaljer för världen medan de gömmer de andra. Abstraktion uppnås i C # med hjälp av abstraktklassen och gränssnittet.

En klass kan deklareras som en abstrakt klass med hjälp av nyckelordet “Abstrakt”. Abstraktklassen i C # är alltid basklassen i hierarkin. Vad som gör dem annorlunda än den andra klassen är att de inte kan instantieras. En C # abstrakt klass måste ärvas.

Exempel:

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 { }

Resultatet av följande är:

Description of the car

Om du jämför det med våra tidigare exempel under arv eller dynamisk polymorfism, kommer du att hitta likheterna. Den mest igenkännliga skillnaden är användningen av abstrakta nyckelord före klassen Bil. Om du vill åsidosätta detta eller tillhandahålla din egen implementering som liknar vad vi gjorde inom dynamisk polymorfism. Då kan du uppnå det med följande.

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'; } }

Så om du kör den här koden nu kommer den att ge följande resultat:

Description of the car is now Hyundai

Den härledda klassmetoden åsidosätter basklassmetoden. På detta sätt kan du skapa en annan härledd klass som Ferrari, Porsche, BMW, etc. med sina egna implementeringsmetoder.

Om du tittar noga kan du se att vår beskrivningsmetod i abstraktklassen inte innehåller någon implementering.

Varför definierar vi sedan tomma metoder?

Detta beror på att en abstraktklass ger en signatur av metoderna och gör det till en skyldighet för underklasserna att skapa en implementering för alla dessa metoder. Detta möjliggör delning av basklassen men samtidigt kontrollerar den också metodimplementeringen av den härledda klassen.

Gränssnitt

I C # är gränssnittet ritningen för en klass. Gränssnittet liknar en abstrakt klass och används för att uppnå hundra procent abstraktion. Alla metoder som beskrivs i gränssnittet är som standard abstrakta. Det har ingen metodkropp och det kan inte instantieras.

Gränssnittet används främst för att uppnå flera arv och full abstraktion. All metodsignatur som deklarerats i gränssnittet ska förses med implementering från klassen eller strukturen som implementerar den.

Exempel:

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'; } }

Utdata från ovanstående kod kommer att vara:

Description of the car is now Hyundai

Här har vi skapat ett gränssnitt Car. Eftersom gränssnittet inte kan ha någon metoddefinition har vi precis angett metodnamnet och returtypen i gränssnittet. Vi implementerade sedan gränssnittet Car till en annan Hyundai-klass. I den implementerade klassen gav vi definitionen för de metoder som definierats inuti gränssnittet.

Slutsats

I det objektorienterade programmeringskonceptet behandlas varje del av programmet som ett objekt. Klass är en samling av liknande typer av element och ett objekt är förekomsten av klassen.

Inkapsling i C # gör det möjligt för användaren att fastställa synligheten för klassen och dess medlemmar. Polymorfism tillåter metoderna att ha samma namn men med olika parametrar inom samma klass eller med samma parameter i en annan klass.

Arv är när en underordnad klass, som också kallas den härledda klassen, ärver alla egenskaper inklusive metoder, objekt, fält etc. i moderklassen, som också kallas basklassen. Abstraktion gör att programmet bara kan visa signaturen samtidigt som detaljerna om implementeringen döljs.

Konsoliderat program

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'; } }

=> Utforska hela serien av C # -träningsövningar här

Rekommenderad läsning

^