C # - Classi
Quando si definisce una classe, si definisce un progetto per un tipo di dati. Questo in realtà non definisce alcun dato, ma definisce il significato del nome della classe. Cioè, in cosa consiste un oggetto della classe e quali operazioni possono essere eseguite su quell'oggetto. Gli oggetti sono istanze di una classe. I metodi e le variabili che costituiscono una classe sono chiamati membri della classe.
Definizione di una classe
Una definizione di classe inizia con la parola chiave class seguita dal nome della classe; e il corpo di classe racchiuso da un paio di parentesi graffe. Di seguito è riportata la forma generale di una definizione di classe:
<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
}
}Nota -
Gli specificatori di accesso specificano le regole di accesso per i membri e per la classe stessa. Se non menzionato, lo specificatore di accesso predefinito per un tipo di classe èinternal. L'accesso predefinito per i membri èprivate.
Il tipo di dati specifica il tipo di variabile e il tipo restituito specifica il tipo di dati dei dati restituiti dal metodo, se presente.
Per accedere ai membri della classe, utilizzare l'operatore punto (.).
L'operatore punto collega il nome di un oggetto con il nome di un membro.
Il seguente esempio illustra i concetti discussi finora:
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();
}
}
}Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:
Volume of Box1 : 210
Volume of Box2 : 1560Funzioni membro e incapsulamento
Una funzione membro di una classe è una funzione che ha la sua definizione o il suo prototipo all'interno della definizione di classe simile a qualsiasi altra variabile. Funziona su qualsiasi oggetto della classe di cui è membro e ha accesso a tutti i membri di una classe per quell'oggetto.
Le variabili membro sono gli attributi di un oggetto (dal punto di vista della progettazione) e vengono mantenute private per implementare l'incapsulamento. È possibile accedere a queste variabili solo utilizzando le funzioni membro pubbliche.
Mettiamo i concetti sopra per impostare e ottenere il valore dei diversi membri della classe in una classe -
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();
}
}
}Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:
Volume of Box1 : 210
Volume of Box2 : 1560Costruttori C #
Una classe constructor è una funzione membro speciale di una classe che viene eseguita ogni volta che creiamo nuovi oggetti di quella classe.
Un costruttore ha esattamente lo stesso nome di quello della classe e non ha alcun tipo di ritorno. L'esempio seguente spiega il concetto di costruttore:
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();
}
}
}Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:
Object is being created
Length of line : 6UN default constructornon ha alcun parametro ma, se necessario, un costruttore può avere parametri. Tali costruttori sono chiamatiparameterized constructors. Questa tecnica aiuta ad assegnare il valore iniziale a un oggetto al momento della sua creazione come mostrato nell'esempio seguente:
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();
}
}
}Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:
Object is being created, length = 10
Length of line : 10
Length of line : 6Distruttori C #
UN destructorè una funzione membro speciale di una classe che viene eseguita ogni volta che un oggetto della sua classe esce dall'ambito. UNdestructor ha esattamente lo stesso nome di quello della classe con una tilde prefissata (~) e non può né restituire un valore né accettare alcun parametro.
Il distruttore può essere molto utile per rilasciare le risorse di memoria prima di uscire dal programma. I distruttori non possono essere ereditati o sovraccaricati.
L'esempio seguente spiega il concetto di distruttore:
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());
}
}
}Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:
Object is being created
Length of line : 6
Object is being deletedMembri statici di una classe C #
Possiamo definire i membri della classe come statici usando staticparola chiave. Quando dichiariamo un membro di una classe come statico, significa che non importa quanti oggetti della classe vengono creati, c'è solo una copia del membro statico.
La parola chiave staticimplica che esiste solo un'istanza del membro per una classe. Le variabili statiche vengono utilizzate per definire le costanti perché i loro valori possono essere recuperati richiamando la classe senza crearne un'istanza. Le variabili statiche possono essere inizializzate al di fuori della funzione membro o della definizione di classe. È inoltre possibile inizializzare le variabili statiche all'interno della definizione della classe.
Il seguente esempio dimostra l'uso di static variables -
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();
}
}
}Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:
Variable num for s1: 6
Variable num for s2: 6Puoi anche dichiarare un file member function come static. Tali funzioni possono accedere solo a variabili statiche. Le funzioni statiche esistono anche prima che l'oggetto venga creato. Il seguente esempio dimostra l'uso distatic functions -
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();
}
}
}Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:
Variable num: 3