Menu

OOPS-concepten in C #: zelfstudie over objectgeoriënteerd programmeren

  • Hoofd
  • Andere
  • OOPS-concepten in C #: zelfstudie over objectgeoriënteerd programmeren

oops concepts c object oriented programming concept tutorial

Probeer Ons Instrument Voor Het Oplossen Van Problemen

In deze tutorial worden de OOPS-concepten in C # uitgelegd. U kunt leren over objectgeoriënteerde programmeerprincipes, zoals polymorfisme, inkapseling, overerving en abstractie:

Objectgeoriënteerd programmeren is een programmeermodel dat werkt volgens een principe dat draait om objecten in plaats van om actie of logica. Hiermee kunnen de gebruikers objecten maken op basis van de vereiste en vervolgens methoden creëren om met die objecten te werken.

Aan deze objecten werken om het gewenste resultaat te verkrijgen, is het doel van objectgeoriënteerd programmeren.

​ Bekijk hier de volledige reeks C # -trainingstutorials

OOPS-concepten in C #

Laten we enkele van de concepten herzien die we in onze eerdere tutorials hebben geleerd !!

Naamruimte

Een naamruimte in C # is een verzameling klassen. Het biedt een structuur om een ​​klassenaam gescheiden te houden van een andere klassenaam door ze in een andere naamruimte te declareren. Zodat de klassen met dezelfde naam niet met elkaar in conflict komen.

Klasse

Een klasse is een blauwdruk van een gegevenstype. Het is eigenlijk een verzameling objecten. Het bevat objecten en de definitie voor de bewerking die op dat object moet worden uitgevoerd.

Voorwerpen

Objecten zijn de instanties van de klasse.

In onze vorige tutorials hebben we al in detail geleerd over Klasse en Objecten.

Wat je leert:

OOPS-concepten in C #

Objectgeoriënteerd programmeren biedt verschillende voordelen ten opzichte van de andere programmeermodellen, zoals:

  1. De nauwkeurige en duidelijke modulaire benadering van programma's biedt eenvoudig begrip en onderhoud.
  2. Klassen en objecten die in het project zijn gemaakt, kunnen in het hele project worden gebruikt.
  3. Door de modulaire aanpak kunnen verschillende modules onafhankelijk van elkaar bestaan, waardoor verschillende ontwikkelaars samen aan verschillende modules kunnen werken.

In deze tutorial zullen we ons meer concentreren op andere belangrijke OOPS-kernconcepten:

  1. Inkapseling
  2. Polymorfisme
  3. Erfenis
  4. Abstractie

Inkapseling

Inkapseling is een objectgeoriënteerd programmeerconcept waarmee programmeurs gegevens en codefragmenten in een behuizing kunnen plaatsen. Door het inkapselingsprogramma te gebruiken, kunt u de leden van de ene klas verbergen voor een andere klas. Het is alsof je een logisch item in een pakket omcirkelt. Het laat alleen relevante informatie buiten toe beschikbaar en zichtbaar en ook dat alleen voor specifieke leden.

Inkapseling wordt geïmplementeerd met behulp van toegangsspecificaties. Access Specifier wordt gebruikt om de zichtbaarheid en toegankelijkheid van het klaslid in C # te definiëren.

C # bevat de volgende toegangsspecificaties.

regex_match c ++
  • Openbaar
  • Privaat
  • Beschermd
  • Intern

De toegangsspecificaties bepalen de zichtbaarheid van de klasse en zijn waarden. Hiermee kunt u gegevens voor een bepaald deel van de code zichtbaar maken en voor een ander deel verbergen. De meest gebruikte zichtbaarheid is openbaar en privé.

Laten we ze eens bekijken.

Openbaar: Met het openbare trefwoord kunnen de leden overal in het project zichtbaar zijn. Deze toegangsspecificatie heeft de minste zichtbaarheidsbeperking.

Privaat: De privé-leden zijn alleen toegankelijk voor het lid binnen dezelfde klas. Dit heeft een van de meest beperkte zichtbaarheid.

Beschermd: Met beveiligde toegankelijkheid kan het lid worden benaderd vanuit de klasse en vanuit een andere klasse die deze klasse erft.

Intern: Intern zorgt voor toegankelijkheid vanuit het project. Een andere vergelijkbare interne toegankelijkheid is intern beveiligd. Dit maakt hetzelfde mogelijk als de interne en het enige verschil is dat een kindklasse deze klasse kan erven en zijn leden zelfs vanuit een ander project kan bereiken.

Polymorfisme

Polymorfisme is afgeleid van het Griekse woordenboek, het betekent een met vele vormen. Poly staat voor veel en Morph betekent vormen. Het staat de klasse in C # toe om meerdere implementaties met dezelfde naam te hebben.

Polymorfisme is in principe verdeeld in twee delen:

  1. Compilatietijd polymorfisme
  2. Runtime polymorfisme

# 1) Statisch of compilatietijdpolymorfisme

Compile-time polymorfisme is ook bekend als statisch polymorfisme. Overbelasting van de methode is een van de manieren waarop compilatietijdpolymorfisme wordt bereikt. Het staat bekend als compilatietijdpolymorfisme, omdat de beslissing over de methode-aanroep wordt genomen op het moment van compileren.

Dit wordt bereikt door de naam van de methode hetzelfde te houden maar verschillende sets parameters door te geven. Bij overbelasting van de methode controleert het systeem eerst de gebruikte parameter en op basis van de set parameters besluit het de juiste methode aan te roepen.

Voorbeeld:

​

In het bovenstaande voorbeeld hebben we dezelfde methode twee keer 'print' genoemd met verschillende parameters. Eerst geven we twee gehele getallen door als parameters, daarna hebben we twee strings als parameters doorgegeven. Er zijn twee 'print' -methoden met dezelfde naam.

Als we een parameter doorgeven met het integersysteem, zal het zoeken naar de methode met de naam 'print' die twee integer-parameters accepteert en het zal dat uitvoeren en andere methoden met dezelfde naam negeren.

In het tweede deel hebben we de stringparameter doorgegeven. Opnieuw zoekt het systeem naar de methode die twee stringparameters accepteert. Daarom voegt de eerste methode, op basis van de doorgegeven parameters, twee gehele getallen toe en de volgende voegt twee strings samen.

# 2) Dynamisch polymorfisme of Runtime-polymorfisme

Runtime-polymorfisme of dynamisch polymorfisme treedt op wanneer zowel de naam van de methode als de handtekening van de methode dezelfde naam en parameters hebben. Methode overschrijven is een voorbeeld van dynamisch polymorfisme. Hiermee kan de gebruiker een abstracte klasse maken met een gedeeltelijke interface-implementatie.

Het overschrijven van de methode wordt bereikt door overerving. Om een ​​methode te bereiken die zowel de basisklasse als de afgeleide klasse overschrijft, moeten deze dezelfde naam en parameter hebben. Tijdens het compileren is de compiler niet in staat de overheersende methode te herkennen en genereert hij daarom geen fout. De beslissing om een ​​methode uit te voeren, wordt genomen tijdens runtime.

Voorbeeld:

​

Als we het bovenstaande programma draaien, krijgen we de volgende output:

​

Hoewel de klasse Execute alle methoden van de klasse Program heeft geërfd, maar als we de methode print aanroepen die in beide klassen aanwezig is, zal de methode die aanwezig is in de kindklasse de methode van de bovenliggende klasse overschrijven.

Dynamisch polymorfisme wordt gebruikt om abstractie te implementeren. Hiermee kan de gebruiker een abstracte klasse maken die wordt gebruikt om een ​​implementatie voor een interface te bieden wanneer deze wordt overgenomen door een afgeleide klasse. De abstracte klasse kan namen / handtekening van de methoden bevatten en de afgeleide klasse kan een meer gespecialiseerde definitie voor de methode hebben.

Erfenis

Overerving is een belangrijk onderdeel van het OOPS-concept. Bij overerving definiëren we bovenliggende en onderliggende klassen. De onderliggende klasse kan alle methoden, objecten en eigenschappen van de bovenliggende klasse erven. Een kinderklasse kan ook zijn eigen methoden en specifieke implementatie hebben.

De bovenliggende klasse is ook bekend als een basisklasse en de onderliggende klasse die de basisklasse erft, wordt ook wel een afgeleide klasse genoemd.

Voorbeeld:

​

Hier hebben we een klasse genaamd een programma met één methode. We hebben nog een klasse Execute die de klasse Program erft. De klasse Execute is de afgeleide klasse en het klasseprogramma staat bekend als de basisklasse.

In plaats van een objectinstantie voor het klasseprogramma te maken, hebben we nu een objectinstantie gemaakt voor de klasse Execute. Met behulp van deze instantie hebben we toegang tot de afdrukmethode vanuit de basisklasse.

De uitvoer van de bovenstaande code is dus:

​

De afgeleide klasse erft niet alleen methoden, maar neemt ook bijna alle klasseleden over, zoals velden, eigenschappen, enzovoort, afhankelijk van de zichtbaarheid. Overerving in C # staat het gebruik van meerdere overervingen niet toe, d.w.z. een klasse kan niet erven van verschillende klassen, maar één klasse kan erven van een andere klasse die kan erven van een andere klasse.

Abstractie

Abstractie is een van de belangrijkste principes van objectgeoriënteerd programmeren. Door abstractie kan de programmeur alleen de noodzakelijke details aan de wereld laten zien terwijl de andere worden verborgen. Abstractie wordt bereikt in C # door de klasse en interface Abstract te gebruiken.

Een klasse kan worden gedeclareerd als een abstracte klasse door het sleutelwoord 'Abstract' te gebruiken. De klasse Abstract in C # is altijd de basisklasse in de hiërarchie. Wat ze anders maakt dan de andere klasse, is dat ze niet kunnen worden geïnstantieerd. Een abstracte klasse C # moet worden overgeërfd.

Voorbeeld:

​

De output van het volgende is:

​

Als je het vergelijkt met onze eerdere voorbeelden tijdens overerving of dynamisch polymorfisme, dan zul je de overeenkomsten ontdekken. Het meest herkenbare verschil is het gebruik van een abstract trefwoord voor de klasse Auto. In het geval dat u dit wilt negeren of uw eigen implementatie wilt bieden, vergelijkbaar met wat we deden in dynamisch polymorfisme. Dan kunt u dat als volgt bereiken.

​

Dus als u deze code nu uitvoert, krijgt u de volgende uitvoer:

​

De afgeleide klassemethode overschrijft de basisklassenmethode. Op deze manier kun je een andere afgeleide klasse creëren zoals Ferrari, Porsche, BMW, etc. met hun eigen implementatiemethodes.

Als je goed kijkt, zie je dat onze beschrijvingsmethode in de abstracte klasse geen enkele implementatie bevat.

Waarom definiëren we dan lege methoden?

Dit komt doordat een Abstract-klasse een handtekening van de methoden geeft en het voor de subklassen een verplichting maakt om een ​​implementatie voor al deze methoden te maken. Dit maakt het delen van de basisklasse mogelijk, maar houdt tegelijkertijd ook de implementatie van de methode van de afgeleide klasse in de gaten.

Koppel

In C # is de interface de blauwdruk van een klasse. De interface is vergelijkbaar met een abstracte klasse en wordt gebruikt om honderd procent abstractie te bereiken. Alle methoden die in de interface worden beschreven, zijn standaard abstract. Het heeft geen hoofdtekst van de methode en kan niet worden geïnstantieerd.

De interface wordt voornamelijk gebruikt om meervoudige overerving en volledige abstractie te bereiken. Alle methodehandtekeningen die in de interface zijn gedeclareerd, moeten worden voorzien van implementatie van de klasse of de struct die deze implementeert.

Voorbeeld:

​

De output van de bovenstaande code zal zijn:

​

Hier hebben we een interface Car gemaakt. Omdat de interface geen methodedefinitie kan hebben, hebben we zojuist de naam van de methode en het retourneringstype in de interface opgegeven. Vervolgens hebben we de interface Car geïmplementeerd in een andere klasse Hyundai. In de geïmplementeerde klasse hebben we de definitie gegeven voor de methoden die in de interface zijn gedefinieerd.

Gevolgtrekking

In het concept Object-Oriented Programming wordt elk programmaonderdeel als een object behandeld. Klasse is een verzameling vergelijkbare typen elementen en een object is de instantie van de klasse.

Door inkapseling in C # kan de gebruiker de zichtbaarheid van de klas en zijn leden vaststellen. Polymorfisme zorgt ervoor dat de methoden dezelfde naam hebben, maar met verschillende parameters binnen dezelfde klasse of met dezelfde parameter in een andere klasse.

Overerving is wanneer een onderliggende klasse die ook bekend staat als de afgeleide klasse, alle eigenschappen erft, inclusief methoden, objecten, velden, enz. Van de bovenliggende klasse die ook bekend staat als de basisklasse. Met abstractie kan het programma alleen de handtekening weergeven terwijl de implementatiedetails worden verborgen.

Geconsolideerd programma

​

​ Bekijk hier de volledige reeks C # -trainingstutorials

Aanbevolen literatuur

^