Menu

OOPS-koncepter i C #: Objektorienteret programmeringskonceptvejledning

  • Vigtigste
  • Andet
  • OOPS-koncepter i C #: Objektorienteret programmeringskonceptvejledning

oops concepts c object oriented programming concept tutorial

Prøv Vores Instrument Til At Fjerne Problemer

Denne vejledning forklarer OOPS-begreberne i C #. Du kan lære om objektorienterede programmeringsprincipper som polymorfisme, indkapsling, arv og abstraktion:

Objektorienteret programmering er en programmeringsmodel, der fungerer på et princip, der drejer sig om objekter snarere end handling eller logik. Det giver brugerne mulighed for at oprette objekter baseret på kravet og derefter oprette metoder til at betjene disse objekter.

At arbejde på disse objekter for at opnå det ønskede resultat er målet med objektorienteret programmering.

=> Udforsk hele serien af ​​C # -træningsvejledninger her

OOPS-koncepter i C #

Lad os revidere nogle af de koncepter, som vi lærte i vores tidligere tutorials !!

Navneområde

Et navneområde i C # er en samling af klasser. Det giver en struktur, der holder et klassenavn adskilt fra et andet klassenavn ved at erklære dem i et andet navneområde. Så klasserne med samme navn ikke kommer i konflikt med hinanden.

Klasse

En klasse er en plan af en datatype. Det er faktisk en samling objekter. Den indeholder objekter og definitionen for den operation, der skal udføres på det objekt.

Objekter

Objekter er klassens forekomster.

I vores tidligere tutorials har vi allerede lært om klasse og objekter i detaljer.

Hvad du lærer:

OOPS-koncepter i C #

Objektorienteret programmering giver flere fordele i forhold til de andre programmeringsmodeller som:

  1. Den nøjagtige og klare modulære tilgang til programmer giver nem forståelse og vedligeholdelse.
  2. Klasser og objekter oprettet i projektet kan bruges på tværs af projektet.
  3. Den modulære tilgang tillader forskellige moduler at eksistere uafhængigt, hvorved flere forskellige udviklere kan arbejde på forskellige moduler sammen.

I denne vejledning vil vi fokusere mere på andre vigtige OOPS-koncepter:

  1. Indkapsling
  2. Polymorfisme
  3. Arv
  4. Abstraktion

Indkapsling

Indkapsling er et objektorienteret programmeringskoncept, der gør det muligt for programmører at pakke data og kodestykker inde i et kabinet. Ved at bruge indkapslingsprogrammet kan du skjule medlemmerne af en klasse fra en anden klasse. Det er som at omslutte et logisk element i en pakke. Det tillader kun relevant information tilgængelig og synlig udenfor og kun for bestemte medlemmer.

Indkapsling implementeres ved hjælp af adgangsspecifikatorer. Access Specifier bruges til at definere klassemedlemmets synlighed og tilgængelighed i C #.

C # indeholder følgende adgangsspecifikatorer.

virtual reality-briller til Xbox 360
  • Offentlig
  • Privat
  • Beskyttet
  • Indre

Adgangsspecifikatorerne definerer klassens synlighed og dens værdier. Det giver dig mulighed for at gøre data synlige for en bestemt del af koden og skjule dem for en anden del. Den mest anvendte synlighed er offentlig og privat.

Lad os se på dem.

Offentlig: Det offentlige nøgleord giver sine medlemmer mulighed for at være synlige hvor som helst inde i projektet. Denne adgangsspecifikator har den mindst synlige begrænsning.

Privat: De private medlemmer har kun adgang til medlemmet inden for samme klasse. Dette har en af ​​de mest begrænsede synligheder.

Beskyttet: Beskyttet tilgængelighed giver adgang til medlemmet inden for klassen og fra en anden klasse, der arver denne klasse.

Indre: Intern giver adgang fra projektet. En anden lignende intern tilgængelighed er beskyttet intern. Dette tillader det samme som den interne og den eneste forskel er, at en barneklasse kan arve denne klasse og nå sine medlemmer selv fra et andet projekt.

Polymorfisme

Polymorfisme er afledt af den græske ordbog, det betyder en med mange former. Poly står for mange, og Morph betyder former. Det giver klassen i C # mulighed for at have flere implementeringer med samme navn.

Polymorfisme er grundlæggende opdelt i to dele:

  1. Kompileringstid polymorfisme
  2. Kør tid polymorfisme

# 1) Statisk eller kompileringstidspolymorfisme

Kompileringstidspolymorfisme er også kendt som statisk polymorfisme. Metodeoverbelastning er en af ​​måderne, hvorpå polymorfisme til kompileringstid opnås. Det er kendt som kompileringstidspolymorfisme, da den metode, der træffer beslutning, træffes på tidspunktet for kompilering.

Det opnås ved at holde metodens navn det samme, men passere forskellige sæt parametre. Ved metodeoverbelastning kontrollerer systemet først den anvendte parameter og baseret på det sæt af parametre, det beslutter at kalde den passende metode.

Eksempel:

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 ovenstående eksempel har vi kaldt den samme metode 'udskriv' to gange ved hjælp af forskellige parametre. Først videregiver vi to heltal som parametre, så har vi bestået to strenge som parametre. Der er to 'udskrivningsmetoder' med samme navn.

Når vi videregiver en parameter med heltalssystemet, vil den kigge efter metoden med navnet “print”, som accepterer to heltalsparametre, og den vil udføre den ignorering af andre metoder med samme navn.

I den anden del passerede vi strengparameteren. Igen vil systemet se efter metoden, der accepterer to strengparametre. Derfor, baseret på de parametre, der er sendt, tilføjer den første metode to heltal, og den næste sammenkæder to strenge.

# 2) Dynamisk polymorfisme eller kørselstidspolymorfisme

Kørselstidspolymorfisme eller dynamisk polymorfisme opstår, når både metodens navn og metodesignatur har samme navn og parametre. Metodeoverstyring er et eksempel på dynamisk polymorfisme. Det giver brugeren mulighed for at oprette en abstrakt klasse med delvis implementering af grænsefladen.

Metodeoverstyring opnås ved hjælp af arv. For at opnå en metode, der tilsidesætter, skal både baseklassen og den afledte klasse have samme navn og parameter. I løbet af kompileringstiden er kompilatoren ikke i stand til at genkende den overordnede metode, hvorfor den ikke kaster nogen fejl. Beslutningen om at køre en metode tages i løbet af løbetiden.

Eksempel:

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

Hvis vi kører ovenstående program, får vi følgende output:

Printing from class Execute

Selvom klassen Execute har arvet alle metoderne i klasseprogrammet, men når vi kalder metoden print, der er til stede i begge klasser, vil metoden til stede i underklassen tilsidesætte metoden fra den overordnede klasse.

Dynamisk polymorfisme bruges til at implementere abstraktion. Det giver brugeren mulighed for at oprette en abstrakt klasse, der bruges til at give en implementering af en grænseflade, når den arves af en afledt klasse. Den abstrakte klasse kan indeholde navne / signatur på metoderne, og den afledte klasse kan have en mere specialiseret definition af metoden.

Arv

Arv er en vigtig del af OOPS-konceptet. I arv definerer vi forældre- og barneklasser. Underklassen kan arve alle metoderne, objekterne og egenskaberne i overordnede klassen. En barneklasse kan også have sine egne metoder og specifik implementering.

Forældreklassen er også kendt som en basisklasse, og den underordnede klasse, der arver basisklassen, er også kendt som afledt klasse.

Eksempel:

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

Her har vi en klasse navngivet som et program, der har en metode. Vi har en anden klasseudførelse, der arver klasseprogrammet. Klassen Execute er den afledte klasse, og klasseprogrammet er kendt som basisklassen.

Nu, i stedet for at oprette en objektforekomst til klasseprogrammet, har vi oprettet en objektforekomst til klasse Udfør. Ved hjælp af denne forekomst kan vi få adgang til udskrivningsmetoden fra basisklassen.

Så output af ovenstående kode vil være:

Printing from class Program

Den afledte klasse arver ikke kun metoder, den arver også næsten alle klassemedlemmer som felter, egenskaber osv. Afhængigt af synligheden. Arv i C # tillader ikke brugen af ​​flere arv, dvs. en klasse kan ikke arve fra flere forskellige klasser, men en klasse kan imidlertid arve fra en anden klasse, som kan arve fra en anden klasse.

Abstraktion

Abstraktion er et af de vigtigste principper for objektorienteret programmering. Abstraktion giver programmøren mulighed for kun at vise de nødvendige detaljer for verden, mens de skjuler de andre. Abstraktion opnås i C # ved hjælp af klassen og grænsefladen Abstrakt.

En klasse kan erklæres som en abstrakt klasse ved hjælp af 'Abstrakt' nøgleordet. Abstraktklassen i C # er altid basisklassen i hierarkiet. Hvad der adskiller dem fra den anden klasse er, at de ikke kan instantieres. En C # abstrakt klasse skal arves.

Eksempel:

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 af følgende er:

Description of the car

Hvis du sammenligner det med vores tidligere eksempler under arv eller dynamisk polymorfisme, så finder du lighederne. Den mest genkendelige forskel er brugen af ​​abstrakte nøgleord inden klassen Bil. Hvis du vil tilsidesætte dette eller give din egen implementering svarende til hvad vi gjorde inden for dynamisk polymorfisme. Så kan du opnå det ved følgende.

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å hvis du udfører denne kode nu, vil den give følgende output:

Description of the car is now Hyundai

Den afledte klassemetode tilsidesætter baseklassemetoden. På denne måde kan du oprette en anden afledt klasse som Ferrari, Porsche, BMW osv. Med deres egne implementeringsmetoder.

Hvis du ser nøje, kan du se, at vores beskrivelsesmetode i abstraktklassen ikke indeholder nogen implementering.

Hvorfor definerer vi så tomme metoder?

Dette skyldes, at en abstrakt klasse giver en signatur af metoderne og gør det til en forpligtelse for underklasserne at oprette en implementering af alle disse metoder. Dette tillader deling af basisklassen, men på samme tid holder den også kontrol med metodens implementering af den afledte klasse.

Interface

I C # er grænsefladen blueprint for en klasse. Interfacet ligner en abstrakt klasse og bruges til at opnå hundrede procent abstraktion. Alle metoder beskrevet inde i grænsefladen er som standard abstrakte. Det har ingen metodekroppe, og det kan ikke instantieres.

Interfacet bruges hovedsageligt til at opnå flere arv og fuld abstraktion. Al metodesignatur, der er erklæret inde i grænsefladen, skal forsynes med implementering fra klassen eller strukturen, der implementerer den.

Eksempel:

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

Outputtet af ovenstående kode vil være:

Description of the car is now Hyundai

Her har vi oprettet et interface Car. Da grænsefladen ikke kan have nogen metodedefinition, har vi netop angivet metodens navn og returtype i grænsefladen. Vi implementerede derefter grænsefladen Car til en anden klasse Hyundai. I den implementerede klasse leverede vi definitionen til de metoder, der er defineret inde i grænsefladen.

Konklusion

I det objektorienterede programmeringskoncept behandles hver del af programmet som et objekt. Klasse er en samling af lignende typer af elementer, og et objekt er forekomsten af ​​klassen.

Indkapsling i C # giver brugeren mulighed for at fastslå synligheden af ​​klassen og dens medlemmer. Polymorfisme tillader metoderne at have samme navn, men med forskellige parametre inden for samme klasse eller med den samme parameter i en anden klasse.

Arv er, når en underordnet klasse, der også er kendt som den afledte klasse, arver alle egenskaberne inklusive metoder, objekter, felter osv. Af overordnede klasse, som også er kendt som basisklassen. Abstraktion tillader, at programmet kun viser signaturen, mens de skjuler implementeringsoplysningerne.

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

=> Udforsk hele serien af ​​C # -træningsvejledninger her

Anbefalet læsning

^