Concetto di classe e oggetto

1. Introduzione

Come avrai già sentito, classe è un modello, mentre oggetto è la sua istanza.
Ma è arrivato il momento di capire classi e oggetti un po' più a fondo!

Immagina di essere un ingegnere progettista in una fabbrica di automobili. Invece di assemblare ogni macchina a mano, crei un disegno tecnico — una specie di istruzione universale secondo cui si possono assemblare tante auto dello stesso tipo. In questo disegno è scritto che l'auto deve avere un motore, ruote, carrozzeria, colore e quali funzioni deve svolgere.

Questo disegno, nel mondo della programmazione, si chiama classe.

E ora immagina che, seguendo questo disegno, la fabbrica abbia prodotto una serie di auto. Ognuna di esse è reale, viaggia per strada, ha il suo numero, colore e anche qualche impostazione individuale. Ma tutte sono state assemblate secondo lo stesso disegno.

Queste auto reali, nel mondo della programmazione, si chiamano oggetti (o istanze della classe).

Quindi, ricordiamolo:

• Classe — è come un disegno tecnico, un modello, uno schema. Descrive quali dati può avere qualcosa (per esempio marca, colore, numero di porte) e cosa può fare (per esempio andare, frenare, suonare il clacson). La classe è solo una descrizione, di per sé non occupa molta memoria e non è qualcosa di "vivo".
• Oggetto — è una "macchina" concreta, assemblata secondo il disegno della classe. È un'entità reale, "viva" nel tuo programma, che occupa spazio in memoria, ha i suoi valori unici per i dati (il suo numero, colore) e può eseguire le azioni descritte nella classe.

Ti sembra un po' astratto? Tranquillo, ora vediamo tutto nel dettaglio.

2. Cos'è una classe?

Classe — è un tipo di dato definito dall'utente che descrive come devono essere fatti gli oggetti di quel tipo: quali caratteristiche (stati/proprietà/campi) hanno e quali azioni si possono fare con loro (comportamenti/metodi/funzioni).

La classe definisce:

• Campi (variabili) — dati che vengono memorizzati nell'oggetto.
• Metodi (funzioni) — azioni che l'oggetto può eseguire.
• Proprietà — metodi speciali per accedere ai dati.
• Eventi — meccanismi per notifiche (ne parleremo più avanti).
• Costruttori — metodi speciali per creare oggetti.

public class Person
{
    // Campi (dati)
    public string Name;
    public int Age;

    // Metodo (azione)
    public void SayHello()
    {
        Console.WriteLine($"Ciao! Mi chiamo {Name}, ho {Age} anni.");
    }
}

In questo esempio abbiamo dichiarato la classe Person. Ha due campi (Name e Age) e un metodo SayHello(). Questo è tutto ciò che serve per una classe base.

3. Cos'è un oggetto?

Oggetto — è un'istanza della classe, cioè un'entità concreta creata in memoria secondo il "disegno" (classe).

Quando crei una variabile di tipo Person, ottieni un oggetto — con valori unici per ogni campo. Non solo una persona, ma, per esempio, una persona di nome Johnny che ha 12 anni. E quando ti saluta (cioè viene chiamato il metodo SayHello()), ti "racconta" qualcosa di sé.

// Creiamo un oggetto della classe Person
Person person1 = new Person();
person1.Name = "Alisa";
person1.Age = 28;
person1.SayHello(); // => Ciao! Mi chiamo Alisa, ho 28 anni.

// Creiamo un altro "umano"
Person person2 = new Person();
person2.Name = "Bob";
person2.Age = 32;
person2.SayHello(); // => Ciao! Mi chiamo Bob, ho 32 anni.

Ogni oggetto non è solo una copia: è un'entità indipendente con i suoi dati (nel nostro esempio — nomi ed età).

4. La differenza principale tra classe e oggetto

La differenza principale:

• Classe — "disegno", istruzione, tipo di dato.
• Oggetto — rappresentante concreto di quel tipo; una "casa" reale costruita secondo il progetto; una "macchina" prodotta secondo il disegno.

Puoi creare quanti oggetti vuoi di una classe. Per esempio, se hai la classe Person, puoi creare un milione di "persone" nel programma.

Perché è comodo e importante?

Proviamo a immaginare un programma senza classi. Se avessimo una lista di studenti, dovremmo memorizzare nome, età, voti e altri dati in array separati per ogni parametro:

string[] studentNames = { "Sergey", "Grisha", "Masha" };
int[] studentAges = { 20, 19, 21 };

// Se serve aggiungere un'altra proprietà, ci sarà un altro array.
// Provare a scambiare due studenti diventa un vero incubo!

Usando le classi, i dati non si sparpagliano in array diversi, ma sono raggruppati in modo logico:

public class Student
{
    public string Name;
    public int Age;
}

Student[] students = new Student[3];
students[0] = new Student { Name = "Sergey", Age = 20 };
students[1] = new Student { Name = "Grisha", Age = 19 };
students[2] = new Student { Name = "Masha", Age = 21 };

Molto più chiaro e comodo! E in più, ora puoi aggiungere metodi a ogni studente (per esempio "salutare" o "calcolare la media dei voti").

Immagine: relazione tra classe e oggetto

+------------------+          +----------------+
|   class Person   |=========>|  person1:      | 
| (disegno/tipo)   |          |  Name = "Alisa"|
|                  |         /|  Age = 28      |
+------------------+        / +----------------+
                          /
+------------------------/----------------------+
                        /
                  +----------------+
                  |  person2:      |
                  |  Name = "Bob"  |
                  |  Age = 32      |
                  +----------------+

5. Dove si usano classi e oggetti nella vita reale?

Classi e oggetti sono la base di qualsiasi applicazione in C#. Tutto quello che vedi in giro in .NET: finestre, bottoni, form, array, collezioni, connessioni al database, log — sono oggetti creati secondo certe classi.

Esempi:

• La classe Button — è l'istruzione su come deve essere un bottone sullo schermo. Ogni volta che crei un nuovo bottone — è un oggetto della classe.
• La classe Stream (dal sistema di input/output): ottieni un oggetto che lavora con i file.
• La tua futura classe User per memorizzare informazioni sugli utenti — di nuovo lo stesso modello.

Breve su nomi, modificatori e convenzioni

• Per le classi si usano nomi con la maiuscola, tipo Person, Order, Product.
• Per le variabili — con la minuscola, tipo person, user1, orderList.
• Di solito la classe si fa public — così è accessibile ovunque nel progetto.