Objecten en constructeurs

1. Een object maken

Nou, we zijn aangekomen bij het maken van objecten. U bent dit al eerder tegengekomen, maar nu zullen we dit onderwerp in meer detail analyseren. Het is eigenlijk heel eenvoudig om objecten te maken.

Om een ​​object te maken, moet u de nieuwe operator gebruiken . Het maken van een object ziet er ongeveer zo uit:

new Class(arguments)

Nadat we een object hebben gemaakt, slaan we er meestal meteen een verwijzing naar op in een variabele, die heel vaak hetzelfde type deelt als het gemaakte object. Dat betekent dat u bij het maken van een object meestal code als deze ziet:

Class name = new Class(arguments)

Waar is de creatie van een nieuwe variabele, en de code rechts van het gelijkteken is de creatie van een nieuw object waarvan het type .Class nameClass

Voorbeelden:

Object o = new Object();

Cat pet = new Cat();

Scanner console = new Scanner(System.in)

Programmeurs noemen variabelen vaak naar hun klassen, maar dan met een kleine letter. Voor een beginnende programmeur kan dergelijke code verwarrend zijn:

BufferedReader bufferedReader = new BufferedReader( reader );

Cat cat = new Cat();

PersonInfo personInfo = new PersonInfo()

Er is niets mis met deze code - dit is de meest gewone code, waarin een variabele wordt gemaakt en vervolgens onmiddellijk wordt geïnitialiseerd door een object van hetzelfde type.

Links van het gelijkteken hebben we de creatie van een variabele. Rechts de creatie van een object. Dat is het.

2. Constructeur

U hebt waarschijnlijk gezien dat sommige argumenten vaak worden doorgegeven bij het maken van een object. Bovendien worden voor sommige objecten wel argumenten doorgegeven, maar voor andere niet. Hoe werkt dit hele mechanisme met argumenten?

Ook hier is alles eenvoudig: elke klasse heeft een speciale methode (of methoden) die verantwoordelijk zijn voor het afhandelen van doorgegeven argumenten bij het maken van een object. Deze methoden worden constructors genoemd . Of als we het maar over één hebben: de constructor .

Het onderscheiden van een constructormethode van een reguliere methode is eenvoudig. Deze methode heeft twee onderscheidende kenmerken:

• de naam van een constructor is hetzelfde als de naam van zijn klasse (en begint met een hoofdletter)
• een constructor heeft geen retourtype.

Over het algemeen ziet het er als volgt uit:

modifiers Class(arguments)
{
   Code
}

Voorbeeld:

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);
   }
}

Merk op hoe de constructor eruitziet: hij heeft geen retourtype en zijn naam is dezelfde als de klassenaam.

En nog een ding: kijk eens naar de code in de constructor. De parameters van de constructor hebben dezelfde naam als de velden van de klasse: x en y. Het is standaardpraktijk om het verzinnen van nieuwe parameternamen te vermijden. De namen zijn dezelfde als die van de velden van de klasse. Het naamconflict wordt opgelost met het trefwoord this.

3. Een constructeur aanroepen

Wanneer u de new- operator en een opdracht zoals "new Class ( argumenten )" gebruikt om een ​​nieuw object te maken, gebeuren er twee dingen:

• De Java-machine maakt een object waarvan het type Class is
• De Java-machine roept de constructor van het object aan en geeft uw argumenten door

Als programmeur mag u beslissen welke constructors uw klasse moet hebben en welke parameters deze constructors moeten hebben.

Stel dat je besluit een klas te maken om katten bij te houden in een dierenasiel. Dan zou je Catklas er zo uit kunnen zien:

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();

De Catklasse heeft slechts één constructor met naam- en leeftijdsparameters. Omdat er geen andere constructors zijn, moet u de naam van de kat ( name) en leeftijd ( age) doorgeven als argumenten bij het maken van een object. Het doorgeven van argumenten aan de constructor is niet optioneel .

4. Meerdere constructeurs

Maar als het nodig is, kunt u meerdere constructors aan de klasse toevoegen. Er is geen limiet op het aantal constructors of hun parameters. Wanneer u een object maakt, selecteert de compiler automatisch de constructor die overeenkomt met de parameters

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();

We besloten rekening te houden met het feit dat de leeftijd van een kat misschien niet bekend is. Om dit geval te behandelen, hebben we de speciale constante toegevoegd UNKNOWNsamen met een constructor die slechts één parameter heeft: de naam van de kat.

Merk op dat we nog steeds beide variabelen binnen beide constructors initialiseren. We vervangen de onbekende/ontbrekende parameters door de constante UNKNOWN.

Als er geen waarde wordt toegekend aan de leeftijdsvariabele, dan heeft deze de standaardwaarde 0. Een op straat gevonden kitten kan immers best 0 volle jaren zijn. Dat betekent dat een nul in de leeftijdsvariabele niet noodzakelijkerwijs "onbekende leeftijd" betekent.

5. Standaardconstructor

Als u wilt dat uw objecten zonder parameters worden geïnstantieerd, moet uw klasse een constructor zonder argumenten declareren.

Een constructor zonder parameters is niet noodzakelijkerwijs een constructor zonder code. Zo'n constructor kan code bevatten die variabelen initialiseert met startwaarden:

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();

Standaard constructeur

Er is een heel belangrijk punt dat u moet weten en onthouden.

Als uw klasse niet één constructor declareert , zal de compiler een standaardconstructor toevoegen, wat een constructor zonder argumenten is met de openbare modifier.

Maar als uw klasse ook maar één constructor declareert , wordt er geen standaardconstructor toegevoegd en moet u deze zelf toevoegen als u dat wilt.

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

Cat cat = new Cat();