Oggetti e costruttori

1. Creare un oggetto

Bene, siamo arrivati ​​alla creazione di oggetti. L'hai già riscontrato prima, ma ora analizzeremo questo argomento in modo più dettagliato. In realtà è molto facile creare oggetti.

Per creare un oggetto, è necessario utilizzare l' operatore new . La creazione di un oggetto assomiglia approssimativamente a questo:

new Class(arguments)

Dopo aver creato un oggetto, molto spesso salviamo immediatamente un riferimento ad esso in una variabile, che molto spesso condivide lo stesso tipo dell'oggetto creato. Ciò significa che quando crei un oggetto, di solito vedi un codice come questo:

Class name = new Class(arguments)

Dove è la creazione di una nuova variabile e il codice a destra del segno di uguale è la creazione di un nuovo oggetto il cui tipo è .Class nameClass

Esempi:

Object o = new Object();

Cat pet = new Cat();

Scanner console = new Scanner(System.in)

I programmatori spesso chiamano le variabili dopo le loro classi, ma con una lettera minuscola. Per un programmatore alle prime armi, tale codice può creare confusione:

BufferedReader bufferedReader = new BufferedReader( reader );

Cat cat = new Cat();

PersonInfo personInfo = new PersonInfo()

Non c'è niente di sbagliato in questo codice: questo è il codice più ordinario, in cui una variabile viene creata e quindi immediatamente inizializzata da un oggetto dello stesso tipo.

A sinistra del segno uguale abbiamo la creazione di una variabile. A destra, la creazione di un oggetto. Questo è tutto.

2. Costruttore

Probabilmente hai visto che alcuni argomenti vengono spesso passati durante la creazione di un oggetto. Inoltre, gli argomenti vengono passati per alcuni oggetti, ma non per altri. Come funziona l'intero meccanismo con gli argomenti?

Anche qui tutto è semplice: ogni classe ha uno o più metodi speciali che sono responsabili della gestione degli argomenti passati durante la creazione di un oggetto. Questi metodi sono chiamati costruttori . O quando ne parliamo solo uno: il costruttore .

Distinguere un metodo di costruzione da un metodo regolare è facile. Questo metodo ha due caratteristiche distintive:

• il nome di un costruttore è uguale al nome della sua classe (e inizia con una lettera maiuscola)
• un costruttore non ha alcun tipo restituito.

In generale, ecco come appare di solito:

modifiers Class(arguments)
{
   Code
}

Esempio:

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

   Point(int x, int y)
   {
      this.x = x;
      this.y = y;
   }
}

public class Solution
{
   public static void main(String[] args)
   {
      Point point = new Point(5, 10);
   }
}

Notare come appare il costruttore: non ha alcun tipo restituito e il suo nome è lo stesso del nome della classe.

E ancora una cosa: dai un'occhiata al codice all'interno del costruttore. I parametri del costruttore hanno gli stessi nomi dei campi della classe: x e y. È pratica standard evitare di inventare nuovi nomi di parametri. I nomi sono gli stessi dei campi della classe. Il conflitto di nomi viene risolto utilizzando la parola chiave this.

3. Chiamare un costruttore

Quando si utilizza l' operatore new e un comando come "new Class ( arguments )" per creare un nuovo oggetto, accadono due cose:

• La macchina Java crea un oggetto il cui tipo è Class
• La macchina Java chiama il costruttore dell'oggetto e passa i tuoi argomenti

Come programmatore, puoi decidere quali costruttori dovrebbe avere la tua classe e quali parametri dovrebbero avere questi costruttori.

Supponiamo che tu decida di creare una classe per tenere traccia dei gatti in un rifugio per animali. Quindi la tua Catclasse potrebbe assomigliare a questa:

class Cat
{
   public String name;
   public int age;

   public Cat(String name, int age)
   {
      this.name = name;
      this.age = age;
   }
}

Cat cat = new Cat("Whiskers", 2);

Cat cat = new Cat("Whiskers");

Cat cat = new Cat();

La Catclasse ha un solo costruttore con parametri nome ed età. Poiché non ci sono altri costruttori, è necessario passare il nome del gatto ( name) e l'età ( age) come argomenti durante la creazione di un oggetto. Il passaggio di argomenti al costruttore non è facoltativo .

4. Costruttori multipli

Ma se necessario, puoi aggiungere più costruttori alla classe. Non c'è limite al numero di costruttori o ai loro parametri. Quando crei un oggetto, il compilatore seleziona automaticamente il costruttore che corrisponde ai parametri

class Cat
{
   public static final int UNKNOWN = -1;
   public String name;
   public int age;

   public Cat(String name, int age)
   {
      this.name = name;
      this.age = age;
   }
   public Cat(String name)
   {
      this.name = name;
      this.age = UNKNOWN; // Unknown
   }
}

Cat cat = new Cat("Whiskers", 2);

Cat cat = new Cat("Whiskers");

Cat cat = new Cat();

Abbiamo deciso di tenere conto del fatto che l'età di un gatto potrebbe non essere nota. Per gestire questo caso, abbiamo aggiunto la costante speciale UNKNOWNinsieme a un costruttore che ha un solo parametro: il nome del gatto.

Si noti che inizializziamo ancora entrambe le variabili all'interno di entrambi i costruttori. Sostituiamo i parametri sconosciuti/mancanti con la costante UNKNOWN.

Se non viene assegnato alcun valore alla variabile età, avrà il valore predefinito 0. Dopo tutto, un gattino trovato per strada potrebbe avere 0 anni interi. Ciò significa che uno zero nella variabile età non significa necessariamente "età sconosciuta".

5. Costruttore predefinito

Se vuoi che i tuoi oggetti vengano istanziati senza alcun parametro, la tua classe deve dichiarare un costruttore senza argomenti.

Un costruttore senza parametri non è necessariamente un costruttore senza codice. Tale costruttore può contenere codice che inizializza variabili con valori iniziali:

class Cat
{
   public static final int UNKNOWN = -1;
   public String name;
   public int age;

   public Cat(String name, int age)
   {
      this.name = name;
      this.age = age;
   }

   public Cat()
   {
      this.name = "Nameless";
      this.age = UNKNOWN; // Unknown
   }
}

Cat cat = new Cat("Whiskers", 2);

Cat cat = new Cat();

Costruttore predefinito

C'è un punto molto importante che dovresti sapere e ricordare.

Se la tua classe dichiara not one constructor , il compilatore aggiungerà un costruttore predefinito, che è un costruttore senza argomenti con il public modificatore.

Ma se la tua classe dichiara anche un costruttore , non verrà aggiunto alcun costruttore predefinito e dovrai aggiungerlo tu stesso se lo desideri.

class Cat
{
   public String name;
   public int age;
}

Cat cat = new Cat();