Oggetti in Java

1. Oggetti

Tutto in Java è un oggetto.

Più precisamente, ci sono pochissime cose in Java che non sono oggetti. Ad esempio, tipi primitivi. Ma questa è un'eccezione piuttosto rara alla regola.

Quindi cos'è un oggetto?

Un oggetto è un'entità che raggruppa i dati insieme ai metodi che elaborano i dati . Quando diciamo "dati", intendiamo variabili, ovviamente.

Le variabili di un oggetto sono chiamate i suoi "dati" o "stato".

Si dice che i metodi di un oggetto siano il suo "comportamento". È consuetudine modificare lo stato di un oggetto (variabili) solo utilizzando i metodi di quell'oggetto. Cambiare direttamente le variabili di un oggetto (non usando i suoi metodi) è considerato una cattiva forma.

Ogni oggetto , così come ogni variabile, ha un tipo . Questo tipo viene determinato una volta creato l'oggetto e non può essere modificato in futuro. Il tipo di un oggetto è la sua classe.

Ogni oggetto ha la propria copia delle variabili di istanza (campi). Se una variabile int a non statica viene dichiarata in una classe e il programma crea 10 oggetti di quella classe, ogni oggetto avrà la propria variabile int a.

Interagire con un oggetto

Il modo più conveniente per lavorare con un oggetto è memorizzare un riferimento ad esso in una variabile e quindi chiamare i metodi su quella variabile. Questo ti sembrerà familiare:

variable.method()

Dove variableè una variabile che memorizza un riferimento a un oggetto ed methodè un metodo di quella classe.

Se vuoi fare riferimento a un campo (variabile) di un oggetto, devi anche usare l' operatore punto :

variable.field

Dove variableè una variabile che memorizza un riferimento a un oggetto ed fieldè una variabile di istanza (campo).

2. newoperatore

Per creare un oggetto di una determinata classe, è necessario utilizzare l' newoperatore. In generale, ecco come si crea un oggetto:

Class variable = new Class(arguments);

Dove Classè il nome della classe della variablevariabile e il nome della classe dell'oggetto da creare. Ed variable è una variabile che memorizza un riferimento all'oggetto creato. Ed argumentsè un segnaposto per un elenco delimitato da virgole di argomenti passati al costruttore.

L'elenco specifico di argomenti che possono essere passati viene deciso dai programmatori che scrivono la classe.

Hai già creato oggetti e persino utilizzato questo particolare costrutto. Non hai dimenticato, spero?

Scanner console = new Scanner(System.in);
int x = console.nextInt();

Scanner console— questo crea una consolevariabile il cui tipo è Scanner. - questo crea un nuovo oggetto. E l'operatore di assegnazione imposta la variabile uguale a un riferimento all'oggetto appena creato.new Scanner(System.in)Scannerconsole

Nella seconda riga, chiamiamo il nextInt()metodo sull'oggetto Scanner, utilizzando la consolevariabile, che memorizza un riferimento all'oggetto Scanner.

Esempi di creazione di oggetti:

String s = new String("Hello");

Scanner console = new Scanner("");

int[] data = new int[10];

Gli oggetti creati sono chiamati oggetti della classe o istanze della classe , mentre la classe è chiamata la classe dell'oggetto . Ad esempio, la svariabile memorizza un riferimento a un'istanza della Stringclasse.

3. Presentazione delle classi

Penso che tu abbia già visto quanto sia molto comodo usare classi scritte da altri programmatori. Ma che ne dici di scrivere le tue lezioni?

Come fai a sapere quando e dove hai bisogno della tua classe e come crearne una?

I programmatori di solito creano le proprie classi quando vogliono portare una nuova entità nel programma. Sembra confuso? Poi cercherò di spiegare, ma inizierò da molto lontano.

Gruppo di dati

Semplificando un po', possiamo dire che un oggetto in Java è un blocco di memoria che contiene le variabili dichiarate in una classe (campi di istanza). O, in altre parole, variabili combinate in un gruppo.

Diciamo che il tuo programma ha bisogno di memorizzare le coordinate dei 100punti e ha bisogno di un metodo per visualizzarle sullo schermo. Questo può essere fatto usando gli array. Ad esempio, in questo modo:

class Solution
{
   public static void printPoints(int[] x, int[] y, int[] color)
   {
     for (int i = 0; i < x.length; i++)
       System.out.println("Color of (" + x[i] + ", " + y[i] + ") = " + color[i]);
   }

   public static void main(String[] args)
   {
     int[] x = new int[100];
     int[] y = new int[100];
     int[] color = new int[100];
     printPoints(x, y, color);
   }
}

Sarebbe molto più conveniente se avessimo un unico tipo per memorizzare tutte le informazioni su un punto: x, y, color. Se un tale tipo non esiste in Java, puoi crearlo tu stesso.

Per fare ciò, scriveremo il codice per una Pointclasse:

public class Point
{
   public int x;
   public int y;
   public int color;
}

Ora il codice sopra può essere riscritto come:

class Solution
{
   public static void printPoints(Point[] points)
   {
     for (int i = 0; i < points.length; i++)
       System.out.println("Color of (" + points[i].x + ", " + point[i].y + ") = " + points[i].color);
   }

   public static void main(String[] args)
   {
     Point[] data = new Point[100];
     for (int i = 0; i < data.length; i++)
       data[i] = new Point();
     printPoints(data);
   }
}

Ora aggiungiamo un metodo alla Pointclasse che visualizzerà informazioni sull'oggetto:

public class Point
{
   public int x;
   public int y;
   public int color;
   public void print()
   {
     System.out.println("Color of (" + x + ", " + y + ") = " + color);
   }
}

Ora la Solutionclasse si presenta così:

class Solution
{
   public static void printPoints(Point[] points)
   {
     for (int i = 0; i < points.length; i++)
       points[i].print();
   }

   public static void main(String[] args)
   {
     Point[] data = new Point[100];
     for (int i = 0; i < data.length; i++)
       data[i] = new Point();
     printPoints(data);
   }
}

Abbiamo abilmente nascosto le coordinate del punto e le informazioni sul colore all'interno della Pointclasse insieme al metodo che visualizza lo stato del punto.

Le classi sono un modo per gestire la complessità del programma. Un programma di grandi dimensioni diventa meno complesso quando viene suddiviso in tante piccole classi.

4. Oggetti mutabili vs oggetti immutabili

Una volta abbiamo studiato le costanti in Java e siamo giunti a una conclusione non molto confortante. Le costanti consentono di proteggere le variabili dalla modifica, ma non possono impedire le modifiche agli oggetti a cui si riferiscono.

Per risolvere questo problema, Java ha ideato oggetti costanti. O, come vengono più frequentemente chiamati, oggetti immutabili.

A proposito, conosci già tale classe, i cui oggetti non possono essere modificati: String. Un Stringoggetto rimane per sempre immutato dopo essere stato creato. E come hanno fatto i creatori di Java a raggiungere questo obiettivo?

Innanzitutto, tutte le variabili della Stringclasse sono nascoste, cioè dichiarate private.

Secondo, non puoi ereditare la Stringclasse: la sua dichiarazione di classe include il finalmodificatore.

In terzo luogo, e cosa più interessante, tutti i metodi della Stringclasse, che, in teoria, ci si aspetterebbe di modificare l'oggetto esistente, in realtà non lo modificano, ma invece ne restituiscono uno nuovo.

Ad esempio, il toUpperCase()metodo rende maiuscole tutte le lettere nella stringa. Ma invece di cambiare l'oggetto su cui viene chiamato il metodo, restituisce un nuovo Stringoggetto composto da lettere maiuscole:

String text = "This is a very important message";
String message = text.toUpperCase();

Questo è ciò che sarà in memoria dopo aver eseguito questo codice:

Quindi sentiti libero di passare le tue stringhe a qualsiasi metodo: nessuno le cambierà.