Classes
1. Inleiding
2. Klassen en objecten
3. Voorbeeld van een klasse en een object
4. Statische klassen
5. Access Modifiers
6. Methodes / Properties
7. Uitgebreid voorbeeld
8. Slot
1. Inleiding
Het is weer even geleden dat er nog eens een .NET tutorial werd gepost. Dit keer heb ik gekozen om
een stukje OO uit te leggen, namelijk het werken met klassen. Aangezien alle talen binnen het
.NET Framework object georienteerd zijn is het nuttig om te weten hoe je met klassen werkt.
Er zal worden uitgelegd wat klassen en objecten zijn en ook de bijbehorende modifiers. Ook attributen,
methodes en properties zullen besproken worden.
top
2. Klassen en objecten
Klassen
Wat is een klasse (class)? Een klasse is in feite een ontwerp dat verschillende attributen en
methodes bevat. Attributen zorgen voor een bepaalde toestand/gedrag van het object en methoden
zorgen voor de toegang tot deze attributen. Attributen zijn enkel toegankelijk via methoden.
Objecten
Een object is niet meer dan de instantie van een klasse. Een object bevindt zich steeds in een bepaalde
toestand. Die toestand wordt bepaald door de waarden van de attributen van het object. De toestand van
het object kan gewijzigd worden als er een methode aangeroepen wordt die een attribuut wijzigt.
Dit lijkt allemaal misschien een beetje raar klinken, maar het voorbeed zal veel verduidelijken.
top
3. Voorbeeld van een klasse en een object
In het onderstaande voorbeeld wordt eenvoudigweg een klasse gedefinieerd:
| C# | VB |
|---|
class mijnKlasse
{
} |
Class mijnKlasse
End Class |
Nu bestaat er een klasse 'mijnKlasse'. Op zich betekent deze klasse niets aangezien er geen attributen
of methodes zijn voorzien om er iets mee te kunnen doen.
In het voorbeeld hieronder wordt een instantie van de klasse gedefinieerd (object):
| C# | VB |
|---|
| mijnKlasse mC = new mijnKlasse(); |
Dim mC As New mijnKlasse() |
Aangezien we een lege klasse hebben en hiervan een instantie maken, hebben we er ook niet veel aan.
Maar het is syntactisch niet verkeerd.
top
4. Statische klassen
Een statische klasse is een klasse die niet kan geinstancieerd worden. Er kan dus geen object zijn
van die klasse. Alle members van de klasse zijn ook statisch en een statische klasse heeft ook geen
default constructor (uitleg over constructor volgt nog).
In C# wordt een statische klasse aangeduid met het keyword 'static', ook de members van de klasse moeten
het keyword 'static' bevatten. In VB wordt het keyword 'Shared' gebruikt, maar niet bij de klasse, enkel voor
de members van de klasse:
| C# | VB |
|---|
static class mijnKlasse
{
} |
Class mijnKlasse
End Class |
top
5. Access Modifiers
Een access modifier is een keyword dat je gebruikt om te bepalen wat voor toegang je geeft aan
bijvoorbeeld een member van een klasse. Zo kan je elke toegang toestaan, overerving en/of het oproepen
van buitenaf tegenhouden. Er zijn vier verschillende Access Modifiers die je kan gebruiken in .NET, namelijk:
| C# | VB |
|---|
- public
- protected
- private
- internal
- protected internal
|
- Public
- Protected
- Private
- Friend
- Protected Friend
|
Je kan maar één modifier toekennen aan een lid, met als enige uitzondering de laatste uit het lijstje, wat een combinatie is van
twee standaard modifiers. Enkel de eerste drie modifiers zullen worden uitgelegd aangezien dat de drie voornaamste zijn die gebruikt worden.
- public / Public (Publiek)
Standaard is een klasse/member steeds public. Er is "volledige toegang", het publieke lid (member) van de klasse kan van buitenaf aangeroepen worden:
| C# | VB |
|---|
class een
{
public string naam;
}
class twee
{
public static string eenName()
{
een e = new een();
e.naam = "C#";
}
} |
Class een
Public naam As String
End Class
Class twee
Public Shared Function eenName() As String
Dim e As New een()
e.naam = "VB"
Return e.naam
End Function
End Class |
Je kan dan bijvoorbeeld dit doen:
|
MessageBox.Show(twee.eenName());
//Output: C# |
MessageBox.Show(twee.eenName())
'Output: VB |
- protected / Protected (beschermd)
Een lid dat protected is, is toegankelijk binnen de klasse waarin het gedeclareerd is. Maar, het lid is ook
toegankelijk vanuit de klasse die afgeleid is van de klasse waarin het lid gedeclareerd is. Let wel: het beschermd lid
is alleen toegankelijk in een afgeleide klasse als de toegang plaatsvindt via het afgeleide klasse-type.
| C# | VB |
|---|
class een
{
protected string naam;
}
class twee : een
{
public static void voerUit()
{
een e = new een();
twee t = new twee();
e.naam = "C#"; //Fout
t.naam = "C#"; //Juist
}
} |
Class een
Protected naam As String
End Class
Class twee
Inherits een
Public Sub voerUit()
Dim e As New een()
Dim t As New twee()
e.naam = "VB" 'Fout
t.naam = "VB" 'Juist
End Sub
End Class |
- private / Private (prive)
Private is de minst toegankelijke modifier. Hierin is het lid, dat prive is, enkel toegankelijk binnen de klasse waarin het gedeclareerd is.
Het is dus niet te "bereiken" van buitenaf, tenzij je een publieke methode gebruikt (uitleg methodes volgt nog), dan kan je wel toegang krijgen tot het lid dat prive is.
In het code-voorbeeld zal je dus zien dat er een publieke methode 'geefNaam()' wordt gebruikt om toegang te krijgen tot het prive-lid 'naam'.
| C# | VB |
|---|
class een
{
private string naam = "C#";;
public string geefNaam()
{
return naam;
}
}
class twee
{
public static void voerUit()
{
een e = new een();
string taal = e.naam; //Fout
string taal = e.geefNaam(); //Juist
}
} |
Class een
Private naam As String = "VB"
Public Function geefNaam() As String
Return naam
End Function
End Class
Class twee
Public Sub voerUit()
Dim e As New een()
Dim naam As String = e.naam 'Fout
Dim naam As String = e.geefNaam() 'Juist
End Sub
End Class |
Als je duidelijk en overzichtelijk wil programmeren is het best dat je altijd een modifier meegeeft aan een member van een klasse!
top
6. Methodes / Properties
Methoden zijn procedures die binnen een object uitgevoerd worden, ze hebben een invloed op de toestand van een object.
Er zijn verschillende soorten methodes:
Een constructor maakt een object aan. In C# en VB is overloading toegestaan. Overloading wil zeggen dat we verscheidene constructors
kunnen hebben met verschillende sets aan parameters. In onderstaande code is 'public mijnKlasse()' de constructor:
| C# | VB |
|---|
class mijnKlasse
{
private string naam;
public mijnKlasse()
{
this.naam = "default";
//default constructor, zonder parameters
}
public mijnKlasse(string naam)
{
//constructor met parameter
this.naam = naam;
}
} |
Class mijnKlasse
Private naam As String
Public Sub New()
Me.naam = "default"
'default constructor, zonder parameters
End Sub
Public Sub New(ByVal naam As String)
Me.naam = naam
'constructor met parameter
End Sub
End Class |
Vrij logisch is dat als een constructor een object aanmaakt, een destructor een object "vernietigt". Hier ga ik voorlopig verder nog niet op in.
- Selectors/ Modifiers (Properties)
In dit punt zijn de twee samengezet omdat een getter en een setter samen een property van een object vormen. Met een setter geef je een waarde aan
een veld in een object, met een getter haal je de waarde van een veld in een object op:
| C# | VB |
|---|
class mijnKlasse
{
private string _naam;
public string Naam
{
get
{
return _naam;
}
set
{
_naam = value;
}
}
}
//of korter, dit kan enkel in C#
class mijnKlasse
{
private string _naam
public string Naam
{
get { return _naam; }
set { _naam = value; }
}
} |
Class mijnKlasse
Private _naam As String
Public Property Naam() As String
Get
Return _naam
End Get
Set(ByVal value As String)
_naam = value
End Set
End Property
End Class |
top
7. Uitgebreid voorbeeld
- Standaard klasse met een default constructor, enkele eigenschappen en enkele methodes:
| C# | VB |
|---|
class Mens
{
//private velden declareren
private string _naam, _geslacht;
private int _geboortejaar;
//default constructor
public Mens()
{
_naam = "Testmens";
_geboortejaar = 1950;
_geslacht = "Undefined";
}
//de properties van de klasse mens
public string Naam
{
get { return _naam; }
set { _naam = value; }
}
public int Geboortejaar
{
get { return _geboortejaar; }
set { _geboortejaar = value; }
}
public string Geslacht
{
get { return _geslacht; }
set { _geslacht = value; }
}
//methode om de leeftijd te berekenen
public int berekenLeeftijd()
{
return (DateTime.Now.Year - _geboortejaar);
}
} |
Class Mens
'private velden declareren
Private _naam, _geslacht As String
Private _geboortejaar As Integer
'default constructor
Public Sub New()
_naam = "Testmens"
_geboortejaar = 1950
_geslacht = "Undefined"
End Sub
'de properties van de klasse mens
Public Property Naam() As String
Get
Return _naam
End Get
Set(ByVal value As String)
_naam = value
End Set
End Property
Public Property Geboortejaar() As Integer
Get
Return _geboortejaar
End Get
Set(ByVal value As Integer)
_geboortejaar = value
End Set
End Property
Public Property Geslacht() As String
Get
Return _geslacht
End Get
Set(ByVal value As String)
_geslacht = value
End Set
End Property
'methode om de leeftijd te berekenen
Public Function berekenLeeftijd() As Integer
Return (DateTime.Now.Year - _geboortejaar)
End Function
End Class |
En zo kan je de klasse gebruiken/aanroepen:
//instantie van de klasse maken (object)
Mens m = new Mens();
//gebruik maken van de setters
m.Naam = "Abbas";
m.Geboortejaar = 1985;
m.Geslacht = "Man";
//gebruik maken van de getters
string naam = m.Naam;
string geslacht = m.Geslacht;
int jaar = m.Geboortejaar;
//de methode aanroepen
int leeftijd = m.berekenLeeftijd(); |
'instantie van de klasse maken (object)
Dim m As New Mens()
'gebruik maken van de setters
m.Naam = "Abbas"
m.Geboortejaar = 1985
m.Geslacht = "Man"
'gebruik maken van de getters
Dim naam As String = m.Naam
Dim geslacht As String = m.Geslacht
Dim jaar As Integer = m.Geboortejaar
'de methode aanroepen
Dim leeftijd As Integer = m.berekenLeeftijd() |
- Statische klasse met enkele methodes:
| C# | VB |
|---|
static class Foo
{
public static string getName()
{
return "C#";
}
public static int getLeeftijd(int jaar)
{
return (DateTime.Now.Year - jaar);
}
} |
Class Foo
Public Shared Function getName() As String
Return "VB"
End Function
Public Shared Function getLeeftijd(ByVal jaar As Integer) As Integer
Return (DateTime.Now.Year - jaar)
End Function
End Class |
En zo kan je de klasse gebruiken/aanroepen:
MessageBox.Show(Foo.getName());
MessageBox.Show(Foo.getLeeftijd(1985).ToString()); |
MessageBox.Show(Foo.getName())
MessageBox.Show(Foo.getLeeftijd(1985).ToString()) |
8. Slot
Zo, hierbij zijn we aan het einde van de tutorial!
Het is niet eenvoudig om het werken met klassen direct onder de knie te krijgen en volledig te begrijpen, maar werken met klassen in .NET is van belang!
In .NET kan je nog veel verder gaan met klassen dan wat hier uitgelegd staat, maar met deze tutorial heb je al een stevige basis om
op voort te bouwen en zelf aan de slag te kunnen. Ik hoop dat ik jullie weer een interessant stukje uit de .NET - wereld heb kunnen bijbrengen. Indien er opmerkingen/vragen zijn, aarzel dan niet om een
reactie te posten of een PM te sturen! Geef ook punten aub zodat ik een idee krijg van hoe goed de tutorial is.
top
|
Wat is jouw favoriete javascript framework? (S: 18, R: 2)
