C# - Klassen
Wanneer u een klasse definieert, definieert u een blauwdruk voor een gegevenstype. Dit definieert eigenlijk geen gegevens, maar het definieert wel wat de klassenaam betekent. Dat wil zeggen, waaruit een object van de klasse bestaat en welke bewerkingen op dat object kunnen worden uitgevoerd. Objecten zijn instanties van een klasse. De methoden en variabelen die een klasse vormen, worden leden van de klasse genoemd.
Een klasse definiëren
Een klassedefinitie begint met de trefwoordklasse gevolgd door de klassenaam; en het klaslichaam omsloten door een paar accolades. Hieronder volgt de algemene vorm van een klassedefinitie −
<access specifier> class class_name {
// member variables
<access specifier> <data type> variable1;
<access specifier> <data type> variable2;
...
<access specifier> <data type> variableN;
// member methods
<access specifier> <return type> method1(parameter_list) {
// method body
}
<access specifier> <return type> method2(parameter_list) {
// method body
}
...
<access specifier> <return type> methodN(parameter_list) {
// method body
}
}
Opmerking −
-
Toegangsspecificaties specificeren de toegangsregels voor de leden en de klasse zelf. Indien niet vermeld, is de standaard toegangsspecificatie voor een klassetype intern . Standaardtoegang voor de leden is privé .
-
Gegevenstype specificeert het type variabele en het retourtype specificeert het gegevenstype van de gegevens die de methode retourneert, indien aanwezig.
-
Om toegang te krijgen tot de klasleden, gebruik je de punt (.) operator.
-
De puntoperator koppelt de naam van een object aan de naam van een lid.
Het volgende voorbeeld illustreert de tot nu toe besproken concepten −
Live demo
using System;
namespace BoxApplication {
class Box {
public double length; // Length of a box
public double breadth; // Breadth of a box
public double height; // Height of a box
}
class Boxtester {
static void Main(string[] args) {
Box Box1 = new Box(); // Declare Box1 of type Box
Box Box2 = new Box(); // Declare Box2 of type Box
double volume = 0.0; // Store the volume of a box here
// box 1 specification
Box1.height = 5.0;
Box1.length = 6.0;
Box1.breadth = 7.0;
// box 2 specification
Box2.height = 10.0;
Box2.length = 12.0;
Box2.breadth = 13.0;
// volume of box 1
volume = Box1.height * Box1.length * Box1.breadth;
Console.WriteLine("Volume of Box1 : {0}", volume);
// volume of box 2
volume = Box2.height * Box2.length * Box2.breadth;
Console.WriteLine("Volume of Box2 : {0}", volume);
Console.ReadKey();
}
}
}
Wanneer de bovenstaande code wordt gecompileerd en uitgevoerd, levert dit het volgende resultaat op −
Volume of Box1 : 210 Volume of Box2 : 1560
Lidfuncties en inkapseling
Een lidfunctie van een klasse is een functie waarvan de definitie of het prototype binnen de klassedefinitie vergelijkbaar is met elke andere variabele. Het werkt op elk object van de klasse waarvan het lid is en heeft toegang tot alle leden van een klasse voor dat object.
Lidvariabelen zijn de attributen van een object (vanuit ontwerpperspectief) en worden privé gehouden om inkapseling te implementeren. Deze variabelen zijn alleen toegankelijk via de openbare lidfuncties.
Laten we bovenstaande concepten plaatsen om de waarde van verschillende klasleden in een klas in te stellen en te krijgen −
Live demo
using System;
namespace BoxApplication {
class Box {
private double length; // Length of a box
private double breadth; // Breadth of a box
private double height; // Height of a box
public void setLength( double len ) {
length = len;
}
public void setBreadth( double bre ) {
breadth = bre;
}
public void setHeight( double hei ) {
height = hei;
}
public double getVolume() {
return length * breadth * height;
}
}
class Boxtester {
static void Main(string[] args) {
Box Box1 = new Box(); // Declare Box1 of type Box
Box Box2 = new Box();
double volume;
// Declare Box2 of type Box
// box 1 specification
Box1.setLength(6.0);
Box1.setBreadth(7.0);
Box1.setHeight(5.0);
// box 2 specification
Box2.setLength(12.0);
Box2.setBreadth(13.0);
Box2.setHeight(10.0);
// volume of box 1
volume = Box1.getVolume();
Console.WriteLine("Volume of Box1 : {0}" ,volume);
// volume of box 2
volume = Box2.getVolume();
Console.WriteLine("Volume of Box2 : {0}", volume);
Console.ReadKey();
}
}
}
Wanneer de bovenstaande code wordt gecompileerd en uitgevoerd, levert dit het volgende resultaat op −
Volume of Box1 : 210 Volume of Box2 : 1560
C#-constructeurs
Een klasse constructor is een speciale lidfunctie van een klasse die wordt uitgevoerd wanneer we nieuwe objecten van die klasse maken.
Een constructor heeft precies dezelfde naam als die van klasse en heeft geen retourtype. Het volgende voorbeeld legt het concept van constructor uit −
Live demo
using System;
namespace LineApplication {
class Line {
private double length; // Length of a line
public Line() {
Console.WriteLine("Object is being created");
}
public void setLength( double len ) {
length = len;
}
public double getLength() {
return length;
}
static void Main(string[] args) {
Line line = new Line();
// set line length
line.setLength(6.0);
Console.WriteLine("Length of line : {0}", line.getLength());
Console.ReadKey();
}
}
}
Wanneer de bovenstaande code wordt gecompileerd en uitgevoerd, levert dit het volgende resultaat op −
Object is being created Length of line : 6
Een standaardconstructor heeft geen parameter, maar als je dat nodig hebt, kan een constructor parameters hebben. Dergelijke constructors worden geparametriseerde constructors genoemd . Deze techniek helpt u om een beginwaarde toe te kennen aan een object op het moment dat het wordt gemaakt, zoals in het volgende voorbeeld wordt getoond −
Live demo
using System;
namespace LineApplication {
class Line {
private double length; // Length of a line
public Line(double len) { //Parameterized constructor
Console.WriteLine("Object is being created, length = {0}", len);
length = len;
}
public void setLength( double len ) {
length = len;
}
public double getLength() {
return length;
}
static void Main(string[] args) {
Line line = new Line(10.0);
Console.WriteLine("Length of line : {0}", line.getLength());
// set line length
line.setLength(6.0);
Console.WriteLine("Length of line : {0}", line.getLength());
Console.ReadKey();
}
}
}
Wanneer de bovenstaande code wordt gecompileerd en uitgevoerd, levert dit het volgende resultaat op −
Object is being created, length = 10 Length of line : 10 Length of line : 6
C#-vernietigers
Een vernietiger is een speciale lidfunctie van een klasse die wordt uitgevoerd wanneer een object van zijn klasse buiten het bereik valt. Een vernietiger heeft exact dezelfde naam als die van de klasse met een prefix tilde (~) en kan geen waarde retourneren en kan ook geen parameters aannemen.
Destructor kan erg handig zijn om geheugenbronnen vrij te geven voordat het programma wordt afgesloten. Destructors kunnen niet worden geërfd of overbelast.
Het volgende voorbeeld legt het concept van destructor uit −
Live demo
using System;
namespace LineApplication {
class Line {
private double length; // Length of a line
public Line() { // constructor
Console.WriteLine("Object is being created");
}
~Line() { //destructor
Console.WriteLine("Object is being deleted");
}
public void setLength( double len ) {
length = len;
}
public double getLength() {
return length;
}
static void Main(string[] args) {
Line line = new Line();
// set line length
line.setLength(6.0);
Console.WriteLine("Length of line : {0}", line.getLength());
}
}
}
Wanneer de bovenstaande code wordt gecompileerd en uitgevoerd, levert dit het volgende resultaat op −
Object is being created Length of line : 6 Object is being deleted
Statische leden van een C#-klasse
We kunnen klasleden als statisch definiëren met behulp van de statische trefwoord. Wanneer we een lid van een klasse als statisch declareren, betekent dit dat ongeacht hoeveel objecten van de klasse worden gemaakt, er slechts één kopie van het statische lid is.
Het zoekwoord statisch houdt in dat er slechts één exemplaar van het lid bestaat voor een klasse. Statische variabelen worden gebruikt voor het definiëren van constanten omdat hun waarden kunnen worden opgehaald door de klasse aan te roepen zonder er een instantie van te maken. Statische variabelen kunnen worden geïnitialiseerd buiten de lidfunctie of klassedefinitie. Je kunt ook statische variabelen initialiseren binnen de klassendefinitie.
Het volgende voorbeeld demonstreert het gebruik van statische variabelen
Live demo
using System;
namespace StaticVarApplication {
class StaticVar {
public static int num;
public void count() {
num++;
}
public int getNum() {
return num;
}
}
class StaticTester {
static void Main(string[] args) {
StaticVar s1 = new StaticVar();
StaticVar s2 = new StaticVar();
s1.count();
s1.count();
s1.count();
s2.count();
s2.count();
s2.count();
Console.WriteLine("Variable num for s1: {0}", s1.getNum());
Console.WriteLine("Variable num for s2: {0}", s2.getNum());
Console.ReadKey();
}
}
}
Wanneer de bovenstaande code wordt gecompileerd en uitgevoerd, levert dit het volgende resultaat op −
Variable num for s1: 6 Variable num for s2: 6
U kunt ook een ledenfunctie declareren als statisch . Dergelijke functies hebben alleen toegang tot statische variabelen. De statische functies bestaan al voordat het object is gemaakt. Het volgende voorbeeld demonstreert het gebruik van statische functies
Live demo
using System;
namespace StaticVarApplication {
class StaticVar {
public static int num;
public void count() {
num++;
}
public static int getNum() {
return num;
}
}
class StaticTester {
static void Main(string[] args) {
StaticVar s = new StaticVar();
s.count();
s.count();
s.count();
Console.WriteLine("Variable num: {0}", StaticVar.getNum());
Console.ReadKey();
}
}
}
Wanneer de bovenstaande code wordt gecompileerd en uitgevoerd, levert dit het volgende resultaat op −
Variable num: 3
C Taal