OLD [G_PRO] Programmeren en OO programmeren
experimentalmerge5
experimentalmerge5
  • Welkom
  • Inleiding
    • Benodigdheden
    • Afspraken code
    • Afspraken oefeningen
    • Nuttige extras
    • Dankwoord
    • Mee helpen?
  • Semester 1: Programming Principles
    • H0: Werken met Visual Studio
      • Introductie tot C#
      • Werken met Visual Studio
      • Je eerste programma
      • Input verwerken met ReadLine
      • Fouten in je code
      • Kleuren in Console
      • Oefeningen
    • H1: Variabelen en datatypes
      • De essentie van C#
      • Datatypes
      • Variabelen
      • Expressies en operators
      • Oefeningen
    • H2: Tekst in code
      • Strings en chars
      • Strings samenvoegen
      • Unicode tonen
      • Oefeningen
      • Uitbreidingsoefeningen
    • H3: Werken met data
      • Casting, conversie en parsing
      • Input verwerken en omzetten
      • Math-library en berekeningen
      • Random
      • Debuggen
      • Oefeningen
    • H4: Beslissingen
      • Beslissingen intro
      • Booleanse logica en operators
      • If
      • Scope van variabelen
      • enum
      • Switch
      • Oefeningen
    • H5: Loops
      • Loops intro
      • While en Do While
      • For
      • Nesting
      • Programma flow analyse
      • Oefeningen deel 1
      • Oefeningen deel 2
      • Oefeningen deel 3
    • H6: Methoden
      • Methoden intro
      • Bibliotheken
      • Geavanceerde methoden
      • Oefeningen
      • Uitbreidingsoefeningen
    • H7: Arrays
      • Array principes
      • Werken met arrays
      • Arrays en methoden
      • N-dimensionale arrays
      • Oefeningen deel 1
      • Oefeningen deel 2
  • Semester 2 : OOP
    • H8: Klassen en objecten
      • OOP Intro
      • Klassen en objecten in C#
      • Methoden en access modifiers
      • Properties
      • DateTime: leren werken met objecten
      • (Klassikale!) smaakmaker OOP
      • Oefeningen
    • H9: Geheugenmanagement bij klassen
      • Objecten en methoden
      • Stack en Heap
      • Null en NullReferenceException
      • Oefeningen
    • H10: Geavanceerde klassen en objecten
      • Constructors
      • Static
      • Spelen met strings
      • Oefeningen
    • H11: Arrays en klassen
      • Arrays van objecten
      • Foreach en var
      • List
      • Oefeningen
      • Extra oefeningen
    • H12: Overerving
      • Overerving intro
      • Constructors bij overerving
      • Virtual en override
      • Base keyword
      • Oefeningen
    • H13: Geavanceerde overerving
      • System.Object
      • Abstract
      • Oefeningen
  • Appendix
    • Ea-ict coding guidelines
    • Oefeningen kerkhof
  • Semester 1 appendix
    • Nice to know stuff
      • Out en Ref parameters
      • Jagged arrays
    • All-In-Projecten
      • Overzicht
      • Console Matrix
      • Ascii filmpjes maken met loops
      • Ascii filmpjes maken met methoden
      • Fun with methods: een verhaalgenerator
      • Tekst-gebaseerd Maze game
      • Conway game of life
  • Semester 2 appendix
    • Nice to know stuff
      • Klassen herbruiken
      • Operator overloading
      • Expression bodied members
    • All-In-Projecten
      • Overzicht
      • OO Textbased Game
      • War Simulator
      • Map Maker
      • Magic The Gathering API
  • Pro (geen leerstof en/of in opbouw)
    • Bitwise operators
    • Generics en collections
      • Generics methoden en types
      • Generic classes en constraints
      • Collections
      • Labo-oefeningen
    • Exception handling
      • Werken met exceptions
      • Waar exceptions plaatsen
      • Zelf uitzonderingen maken
    • Events
      • Events
      • Chat server
    • Software engineering
      • SOLID
Powered by GitBook
On this page
  • Overerving
  • Is-een relatie
  • Inheritance in CS
  • Multiple inheritance
  • Transitive
  • Protected
  • Sealed
  • Kennisclip

Was this helpful?

Export as PDF
  1. Semester 2 : OOP
  2. H12: Overerving

Overerving intro

PreviousH12: OverervingNextConstructors bij overerving

Last updated 5 years ago

Was this helpful?

Overerving

Overerving (inheritance) laat ons toe om klassen te specialiseren vanuit een reeds bestaande basisklasse. Wanneer we een klasse van een andere klasse overerven dan zeggen we dat deze nieuwe klasse een child-klasse of sub-klasse is van de bestaande parent-klasse of super-klasse.

De child-klasse kan alles wat de parent-klasse kan, maar de nieuwe klasse kan nu ook extra specialisatie code krijgen.

Is-een relatie

Wanneer twee klassen met behulp van een "x is een y"-relatie kunnen beschreven worden dan weet je dat overerving mogelijk.

  • Een paard is een dier (paard = child-klasse, dier= parent-klasse)

  • Een tulp is een plant

Opgelet: wanneer we "x heeft een y" zeggen gaat het niet over overerving, maar over .

Inheritance in CS

Overving duid je aan met behulp van het dubbele punt(:) bij de klassedefinitie:

Een voorbeeld:

class Paard: Dier
{
   public bool KanHinnikken{get;set;}
}

class Dier
{
   public void Eet()
   {
    //...
   }
}

Objecten van het type Dier kunnen enkel de Eet-methode aanroepen. Objecten van het type Paard kunnen de Eet-methode aanroepen én ze hebben ook een property KanHinnikken:

Dier aDier= new Dier();
Paard bPaard= new Paard();
aDier.Eet();
bPaard.Eet();
bPaard.KanHinnikken=false;
aDier.KanHinnikken=false; //!!! zal niet werken!

Multiple inheritance

In C# is het niet mogelijk om een klasse van meer dan een parent-klasse te laten overerven (zogenaamde multiple inheritance), wat wel mogelijk is in sommige andere object georiënteerde talen.

Transitive

Overerving in C# is transitief, dit wil zeggen dat de child-klasse niet alleen overerft van haar ouderklasse, maar ook van grootouderklassen enzovoort. Je zou bijvoorbeeld een subklasse Pony van de klasse Paard kunnen toevoegen. Een Pony is een Paard en een Paard is een Dier, dus een Pony is ook een Dier en heeft bijvoorbeeld een methode Eet.

Protected

Ook al heeft een subklasse alle onderdeeltjes van een ouderklasse, hou er rekening mee dat private variabelen en methoden van de parent-klasse NIET rechtsreeks aanroepbaar zijn in de child-klasse. Private betekent namelijk: "enkel toegankelijk binnenin deze klasse". Private geeft aan dat het element enkel in de klasse zichtbaar is:

class Paard: Dier
{
   public void MaakOuder()
   {
      leeftijd++; //  !!! dit zal error geven!
   }
}

class Dier
{
   private int leeftijd;
}

Een Paard heeft nog wel een leeftijd, maar binnenin de code voor de klasse Paard kan je de leeftijd niet zomaar opvragen of aanpassen.

Je kan dit oplossen door de protected access modifier ipv private te gebruiken. Met protected geef je aan dat het element enkel zichtbaar is binnen de klasse en binnen child-klassen:

class Paard: Dier
{
   public void MaakOuder()
   {
      leeftijd++; //  werkt nu wel
   }
}

class Dier
{
   protected int leeftijd;
}

Sealed

Soms wil je niet dat van een klasse nog nieuwe klasse kunnen overgeërfd worden. Je lost dit op door het keyword sealed voor de klasse te zetten:

sealed class DoNotInheritMe
{
   //...
}

Als je later dan dit probeert:

class ChildClass:DoNotInheritMe
{
   //...
}

zal dit resulteren in een foutoodschap, namelijk cannot derive from sealed type 'DoNotInheritMe'.

Kennisclip

compositie
Overerving overzicht