oops concepts c object oriented programming concept tutorial
Denne opplæringen forklarer OOPS-konseptene i C #. Du kan lære om objektorienterte programmeringsprinsipper som polymorfisme, innkapsling, arv og abstraksjon:
Objektorientert programmering er en programmeringsmodell som fungerer på et prinsipp som dreier seg om objekter i stedet for handling eller logikk. Det lar brukerne lage objekter basert på kravet og deretter lage metoder for å operere på disse objektene.
Å jobbe med disse objektene for å oppnå ønsket resultat er målet med objektorientert programmering.
=> Utforsk hele serien av C # Training Tutorials her
La oss revidere noen av konseptene som vi lærte i våre tidligere veiledninger !!
Navneområde
Et navneområde i C # er en samling klasser. Det gir en struktur for å holde et klassenavn adskilt fra et annet klassenavn ved å erklære det i et annet navneområde. Slik at klassene med samme navn ikke kommer i konflikt med hverandre.
Klasse
En klasse er en tegning av en datatype. Det er faktisk en samling objekter. Den inneholder objekter og definisjonen for operasjonen som må utføres på det objektet.
Objekter
Objekter er forekomsten av klassen.
I våre tidligere veiledninger har vi allerede lært om klasse og objekter i detalj.
Hva du vil lære:
OOPS-konsepter i C #
Objektorientert programmering gir flere fordeler i forhold til andre programmeringsmodeller som:
- Den presise og klare modulære tilnærmingen for programmer gir enkel forståelse og vedlikehold.
- Klasser og objekter opprettet i prosjektet kan brukes på tvers av prosjektet.
- Den modulære tilnærmingen tillater at forskjellige moduler eksisterer uavhengig, og derved tillater flere forskjellige utviklere å jobbe på forskjellige moduler sammen.
I denne opplæringen vil vi fokusere mer på andre viktige OOPS-konsepter:
- Innkapsling
- Polymorfisme
- Arv
- Abstraksjon
Innkapsling
Encapsulation er et objektorientert programmeringskonsept som gjør det mulig for programmerere å pakke inn data og kodebiter inne i et kabinett. Ved å bruke innkapslingsprogrammet kan du skjule medlemmene i en klasse fra en annen klasse. Det er som å omslutte et logisk element i en pakke. Det tillater bare relevant informasjon tilgjengelig og synlig utenfor, og det også bare for bestemte medlemmer.
Innkapsling implementeres ved hjelp av tilgangsspesifikatorer. Access Specifier brukes til å definere synligheten og tilgjengeligheten til klassemedlemmet i C #.
C # inneholder følgende tilgangsspesifikatorer.
hvordan du skriver ut strengarray i java ved hjelp av for loop
- Offentlig
- Privat
- Beskyttet
- Innvendig
Tilgangsspesifikatorene definerer synligheten til klassen og dens verdier. Det lar deg synliggjøre data for en bestemt del av koden og skjule den for en annen del. Den mest brukte synligheten er offentlig og privat.
La oss se på dem.
Offentlig: Det offentlige nøkkelordet gjør at medlemmene kan være synlige hvor som helst i prosjektet. Denne tilgangsspesifikatoren har minst synlighetsbegrensning.
Privat: De private medlemmene har bare tilgang til medlemmet i samme klasse. Dette har en av de mest begrensede synlighetene.
Beskyttet: Beskyttet tilgjengelighet gjør det mulig å få tilgang til medlemmet fra klassen og fra en annen klasse som arver denne klassen.
Innvendig: Intern gir tilgjengelighet fra prosjektet. En annen lignende intern tilgjengelighet er beskyttet internt. Dette tillater det samme som den interne og den eneste forskjellen er at en barneklasse kan arve denne klassen og nå medlemmene sine selv fra et annet prosjekt.
Polymorfisme
Polymorfisme er avledet fra den greske ordboken, det betyr en med mange former. Poly står for mange og Morph betyr former. Det lar klassen i C # ha flere implementeringer med samme navn.
Polymorfisme er i utgangspunktet delt i to deler:
- Kompileringstid polymorfisme
- Kjør tid polymorfisme
# 1) Statisk eller kompileringstidspolymorfisme
Kompileringstidspolymorfisme er også kjent som Statisk polymorfisme. Metodeoverbelastning er en av måtene man oppnår kompileringstidspolymorfisme på. Det er kjent som kompileringstidspolymorfisme, da metoden som kaller beslutningen tas på tidspunktet for kompilering.
Det oppnås ved å holde metodens navn likt, men passere forskjellige sett med parametere. Ved metodeoverbelastning sjekker systemet først parameteren som brukes, og basert på settet med parameter, bestemmer det seg for å kalle den riktige metoden.
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 eksemplet ovenfor har vi kalt den samme metoden 'skrive ut' to ganger ved hjelp av forskjellige parametere. Først passerer vi to heltall som parametere, så har vi passert to strenger som parametere. Det er to 'utskriftsmetoder' med samme navn.
Når vi sender en parameter med heltallssystemet, vil den se etter metoden som heter “print” som godtar to heltallsparametere, og den vil utføre den ignorering av andre metoder med samme navn.
I den andre delen passerte vi strengparameteren. Igjen vil systemet se etter metoden som godtar to strengparametere. Derfor, basert på parametrene som er sendt, vil den første metoden legge til to heltall, og den neste vil sammenkoble to strenger.
# 2) Dynamisk polymorfisme eller kjøretidspolymorfisme
Runtime polymorfisme eller dynamisk polymorfisme oppstår når både metodenavn og metodesignatur har samme navn og parametere. Metodeoverstyring er et eksempel på dynamisk polymorfisme. Det lar brukeren lage en abstrakt klasse med delvis grensesnittimplementering.
Overstyring av metoden oppnås ved hjelp av arv. For å oppnå metode som overstyrer både baseklassen og den avledede klassen, bør de ha samme navn og parameter. I løpet av kompileringstiden er ikke kompilatoren i stand til å gjenkjenne den overordnede metoden, derfor kaster den ingen feil. Beslutningen om å kjøre en metode tas i løpet av kjøretiden.
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 kjører programmet ovenfor, får vi følgende utdata:
Printing from class Execute
Selv om klassen Execute har arvet alle metodene i klasseprogrammet, men når vi kalte metodeutskriften som er tilstede i begge klassene, vil metoden som er tilstede i underklassen overstyre metoden fra foreldreklassen.
Dynamisk polymorfisme brukes til å implementere abstraksjon. Det lar brukeren lage en abstrakt klasse som brukes til å gi en implementering for et grensesnitt når den arves av en avledet klasse. Den abstrakte klassen kan inneholde navn / signatur på metodene, og den avledede klassen kan ha en mer spesialisert definisjon for metoden.
Arv
Arv er en viktig del av OOPS-konseptet. I arv definerer vi foreldre- og barneklasser. Barneklassen kan arve alle metodene, objektene og egenskapene til foreldreklassen. En barneklasse kan også ha sine egne metoder og spesifikk implementering.
Foreldreklassen er også kjent som en basisklasse, og barneklassen som arver basisklassen er også kjent som avledet 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 som heter et program som har en metode. Vi har en annen klasse Execute som arver klasseprogrammet. Klassen Utfør er den avledede klassen, og klasseprogrammet er kjent som basisklassen.
Nå, i stedet for å lage en objektforekomst for klasseprogrammet, har vi opprettet en objektforekomst for klasse Utfør. Ved å bruke denne forekomsten kan vi få tilgang til utskriftsmetoden fra basisklassen.
Så, resultatet av koden ovenfor vil være:
Printing from class Program
Den avledede klassen arver ikke bare metoder, den arver også nesten alle klassemedlemmer som felt, egenskaper osv. Avhengig av synligheten. Arv i C # tillater ikke bruk av flere arv, dvs. en klasse kan ikke arve fra flere forskjellige klasser, men en klasse kan arve fra en annen klasse som kan arve fra en annen klasse.
Abstraksjon
Abstraksjon er et av hovedprinsippene for objektorientert programmering. Abstraksjon lar programmereren bare vise de nødvendige detaljene for verden mens de gjemmer de andre. Abstraksjon oppnås i C # ved å bruke abstraktklassen og grensesnittet.
En klasse kan erklæres som en abstrakt klasse ved å bruke nøkkelordet “Abstrakt”. Abstraktklassen i C # er alltid basisklassen i hierarkiet. Det som gjør dem forskjellige fra den andre klassen, er at de ikke kan instantiseres. En C # abstrakt klasse må 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 av følgende er:
Description of the car
Hvis du sammenligner det med våre tidligere eksempler under arv eller dynamisk polymorfisme, så vil du finne likhetene. Den mest gjenkjennelige forskjellen er bruken av abstrakte nøkkelord før klassen Bil. I tilfelle du vil overstyre dette eller gi din egen implementering som ligner på det vi gjorde i dynamisk polymorfisme. Da kan du oppnå 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 utfører denne koden nå, vil den gi følgende utdata:
Description of the car is now Hyundai
Den avledede klassemetoden overstyrer baseklassemetoden. På denne måten kan du lage en annen avledet klasse som Ferrari, Porsche, BMW, etc. med sine egne implementeringsmetoder.
Hvis du ser nøye etter, kan du se at beskrivelsesmetoden vår i abstraktklassen ikke inneholder noen implementering.
Så hvorfor definerer vi tomme metoder?
Dette er fordi en abstrakt klasse gir en signatur av metodene og gjør det til en forpliktelse for underklassene å lage en implementering for alle disse metodene. Dette tillater deling av basisklassen, men samtidig kontrollerer den også metodens implementering av den avledede klassen.
Grensesnitt
I C # er grensesnittet blåkopien til en klasse. Grensesnittet ligner på en abstrakt klasse og brukes til å oppnå hundre prosent abstraksjon. Alle metodene som er beskrevet i grensesnittet er som standard abstrakte. Den har ingen metodekropp, og den kan ikke instantieres.
Grensesnittet brukes hovedsakelig for å oppnå flere arv og full abstraksjon. All metodesignatur som er angitt i grensesnittet, skal være utstyrt med implementering fra klassen eller strukturen som 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'; } }
Resultatet av koden ovenfor vil være:
Description of the car is now Hyundai
Her har vi laget et grensesnitt Car. Siden grensesnittet ikke kan ha noen metodedefinisjon, har vi nettopp oppgitt metodens navn og returtype i grensesnittet. Vi implementerte deretter grensesnittet Car til en annen klasse Hyundai. I den implementerte klassen ga vi definisjonen for metodene som er definert inne i grensesnittet.
Konklusjon
I det objektorienterte programmeringskonseptet blir hver del av programmet behandlet som et objekt. Klasse er en samling av lignende typer elementer, og et objekt er forekomsten av klassen.
Innkapsling i C # lar brukeren etablere synligheten til klassen og dens medlemmer. Polymorfisme tillater at metodene har samme navn, men med forskjellige parametere i samme klasse eller med samme parameter i en annen klasse.
Arv er når en underordnet klasse som også er kjent som den avledede klassen, arver alle egenskapene inkludert metoder, objekter, felt osv. Av overordnede klassen som også er kjent som basisklassen. Abstraksjon lar programmet bare vise signaturen mens den skjuler implementeringsdetaljene.
Konsolidert 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'; } }
=> Utforsk hele serien av C # Training Tutorials her
Anbefalt lesing
- OOP Java: Introduksjon til objektorientert programmering i Java
- Objektorientert programmering i C ++
- Unix Pipes Tutorial: Pipes in Unix Programming
- Python DateTime Tutorial med eksempler
- Object Repository i QTP - Opplæring # 22
- Python OOPs-konsepter (Python-klasser, gjenstander og arv)
- QTP Tutorial # 7 - QTP’s Object Identification Paradigm - How QTP Identify Objects Uniqueely?
- Lær avanserte SoapUI Groovy Scripting Concepts - SoapUI Tutorial # 9