Classi e oggetti Java

1. Panoramica

In questo rapido tutorial, esamineremo due elementi costitutivi di base del linguaggio di programmazione Java: classi e oggetti. Sono concetti di base della programmazione orientata agli oggetti (OOP), che utilizziamo per modellare entità della vita reale.

In OOP, le classi sono schemi o modelli per oggetti. Li usiamo per descrivere tipi di entità.

D'altra parte, gli oggetti sono entità viventi, create dalle classi. Contengono determinati stati nei loro campi e presentano determinati comportamenti con i loro metodi.

2. Classi

In poche parole, una classe rappresenta una definizione o un tipo di oggetto. In Java, le classi possono contenere campi, costruttori e metodi.

Vediamo un esempio utilizzando una semplice classe Java che rappresenta un'auto :

class Car { // fields String type; String model; String color; int speed; // constructor Car(String type, String model, String color) { this.type = type; this.model = model; this.color = color; } // methods int increaseSpeed(int increment) { this.speed = this.speed + increment; return this.speed; } // ... } 

Questa classe Java rappresenta un'auto in generale. Possiamo creare qualsiasi tipo di auto da questa classe. Usiamo i campi per mantenere lo stato e un costruttore per creare oggetti da questa classe.

Ogni classe Java ha un costruttore vuoto per impostazione predefinita. Lo usiamo se non forniamo un'implementazione specifica come abbiamo fatto sopra. Ecco come cercherebbe il costruttore predefinito per la nostra classe Car :

Car(){} 

Questo costruttore inizializza semplicemente tutti i campi dell'oggetto con i loro valori predefiniti. Le stringhe vengono inizializzate su null e gli interi su zero.

Ora, la nostra classe ha un costruttore specifico perché vogliamo che i nostri oggetti abbiano i loro campi definiti quando li creiamo:

Car(String type, String model) { // ... } 

Per riassumere, abbiamo scritto una classe che definisce un'auto. Le sue proprietà sono descritte da campi, che contengono lo stato degli oggetti della classe, e il suo comportamento è descritto usando metodi.

3. Oggetti

Mentre le classi vengono tradotte durante la fase di compilazione, gli oggetti vengono creati dalle classi in fase di esecuzione .

Gli oggetti di una classe sono chiamati istanze e li creiamo e li inizializziamo con i costruttori:

Car focus = new Car("Ford", "Focus", "red"); Car auris = new Car("Toyota", "Auris", "blue"); Car golf = new Car("Volkswagen", "Golf", "green"); 

Ora, abbiamo creato diversi oggetti Car , tutti da un'unica classe. Questo è il punto di tutto, definire il progetto in un unico punto e poi riutilizzarlo molte volte in molti luoghi.

Finora abbiamo tre oggetti Auto e sono tutti parcheggiati poiché la loro velocità è zero. Siamo in grado di cambiare questo invocando la nostra increaseSpeed metodo:

focus.increaseSpeed(10); auris.increaseSpeed(20); golf.increaseSpeed(30); 

Ora, abbiamo cambiato lo stato delle nostre auto: si muovono tutte a velocità diverse.

Inoltre, possiamo e dobbiamo definire il controllo dell'accesso alla nostra classe, ai suoi costruttori, campi e metodi. Possiamo farlo usando i modificatori di accesso, come vedremo nella prossima sezione.

4. Modificatori di accesso

Negli esempi precedenti, abbiamo omesso i modificatori di accesso per semplificare il codice. In questo modo, abbiamo effettivamente utilizzato un modificatore di pacchetto privato predefinito. Quel modificatore consente l'accesso alla classe da qualsiasi altra classe nello stesso pacchetto.

Di solito, useremmo un modificatore pubblico per i costruttori per consentire l'accesso da tutti gli altri oggetti:

public Car(String type, String model, String color) { // ... } 

Ogni campo e metodo nella nostra classe dovrebbe anche aver definito il controllo dell'accesso da un modificatore specifico. Le classi di solito hanno modificatori pubblici , ma tendiamo a mantenere privati ​​i nostri campi .

I campi contengono lo stato del nostro oggetto, quindi vogliamo controllare l'accesso a quello stato. Possiamo mantenerne alcuni privati e altri pubblici . Raggiungiamo questo obiettivo con metodi specifici chiamati getter e setter.

Diamo un'occhiata alla nostra classe con controllo degli accessi completamente specificato:

public class Car { private String type; // ... public Car(String type, String model, String color) { // ... } public String getColor() { return color; } public void setColor(String color) { this.color = color; } public int getSpeed() { return speed; } // ... } 

La nostra classe è contrassegnata come pubblica , il che significa che possiamo usarla in qualsiasi pacchetto. Inoltre, il costruttore è pubblico , il che significa che possiamo creare un oggetto da questa classe all'interno di qualsiasi altro oggetto.

I nostri campi sono contrassegnati come privati , il che significa che non sono accessibili direttamente dal nostro oggetto , ma forniamo l'accesso tramite getter e setter.

I campi tipo e modello non hanno getter e setter, perché contengono dati interni dei nostri oggetti. Possiamo definirli solo tramite il costruttore durante l'inizializzazione.

Inoltre, è possibile accedere e modificare il colore , mentre la velocità è solo accessibile, ma non modificata. Abbiamo applicato le regolazioni della velocità tramite metodi pubblici specializzati aumentareSpeed ​​() e diminuireSpeed ​​() .

In altre parole, utilizziamo il controllo dell'accesso per incapsulare lo stato dell'oggetto.

5. conclusione

In questo articolo, abbiamo esaminato due elementi di base del linguaggio Java, delle classi e degli oggetti e abbiamo mostrato come e perché vengono utilizzati. Abbiamo anche introdotto le basi del controllo degli accessi e dimostrato il suo utilizzo.

Per apprendere altri concetti del linguaggio Java, suggeriamo di leggere l'ereditarietà, la parola chiave super e le classi astratte come passaggio successivo.

Il codice sorgente completo per l'esempio è disponibile su GitHub.