Objecten op Java

1. Voorwerpen

Alles in Java is een object.

Nauwkeuriger gezegd, er zijn maar heel weinig dingen in Java die geen objecten zijn. Bijvoorbeeld primitieve typen. Maar dit is een vrij zeldzame uitzondering op de regel.

Dus wat is een voorwerp?

Een object is een entiteit die gegevens groepeert met methoden die de gegevens verwerken . Als we 'gegevens' zeggen, bedoelen we natuurlijk variabelen.

De variabelen van een object worden de "data" of "state" genoemd.

De methoden van een object zouden zijn "gedrag" zijn. Het is gebruikelijk om de status (variabelen) van een object alleen te wijzigen met behulp van de methoden van dat object. Het rechtstreeks wijzigen van de variabelen van een object (niet met behulp van de methoden) wordt als een slechte vorm beschouwd.

Elk object , evenals elke variabele, heeft een type . Dit type wordt eenmalig bepaald bij het aanmaken van het object en kan in de toekomst niet worden gewijzigd. Het type van een object is zijn klasse.

Elk object heeft zijn eigen exemplaar van instantievariabelen (velden). Als een niet-statische int a-variabele wordt gedeclareerd in een klasse en uw programma maakt 10 objecten van die klasse, dan heeft elk object zijn eigen int a-variabele.

Interactie met een object

De handigste manier om met een object te werken, is door er een verwijzing naar op te slaan in een variabele en vervolgens methoden op die variabele aan te roepen. Dit komt je bekend voor:

variable.method()

Waar variableis een variabele die een verwijzing naar een object opslaat, en methodis een methode van die klasse.

Als je wilt verwijzen naar een veld (variabele) van een object, dan moet je ook de puntoperator gebruiken :

variable.field

Waar variableis een variabele die een verwijzing naar een object opslaat, en fieldis een instantievariabele (veld).

2. newexploitant

Om een ​​object van een bepaalde klasse te maken, moet u de operator gebruiken new. Over het algemeen ziet het er als volgt uit om een ​​object te maken:

Class variable = new Class(arguments);

Waar Classis de naam van de klasse van de variablevariabele en de naam van de klasse van het te maken object. En variable is een variabele die een verwijzing naar het gemaakte object opslaat. En argumentsis een tijdelijke aanduiding voor een door komma's gescheiden lijst met argumenten die aan de constructor worden doorgegeven.

De specifieke lijst met argumenten die kunnen worden doorgegeven, wordt bepaald door de programmeurs die de klasse schrijven.

Je hebt eerder objecten gemaakt en zelfs deze specifieke constructie gebruikt. Je bent het niet vergeten, hoop ik?

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

Scanner console— dit creëert een consolevariabele waarvan het type is Scanner. — dit creëert een nieuw object. En de toewijzingsoperator stelt de variabele gelijk aan een verwijzing naar het nieuw gemaakte object.new Scanner(System.in)Scannerconsole

In de tweede regel roepen we de nextInt()methode op het Scannerobject aan, met behulp van de consolevariabele, die een verwijzing naar het Scannerobject opslaat.

Voorbeelden van het maken van objecten:

String s = new String("Hello");

Scanner console = new Scanner("");

int[] data = new int[10];

De gemaakte objecten worden objecten van de klasse of instanties van de klasse genoemd , terwijl de klasse de klasse van het object wordt genoemd . De variabele slaat bijvoorbeeld seen verwijzing op naar een instantie van de Stringklasse.

3. Kennismaken met lessen

Ik denk dat je al hebt gezien hoe handig het is om klassen te gebruiken die door andere programmeurs zijn geschreven. Maar hoe zit het met het schrijven van je eigen lessen?

Hoe weet je wanneer en waar je je eigen klas nodig hebt en hoe je er een kunt maken?

Programmeurs maken meestal hun eigen klassen wanneer ze een nieuwe entiteit in het programma willen opnemen. Klinkt dat verwarrend? Dan zal ik het proberen uit te leggen, maar ik begin van ver.

Groep gegevens

Een beetje vereenvoudigend, kunnen we zeggen dat een object in Java een geheugenblok is dat de variabelen bevat die in een klasse zijn gedeclareerd (instantievelden). Of, met andere woorden, variabelen samengevoegd tot een groep.

Laten we zeggen dat uw programma de coördinaten van punten moet opslaan 100en een methode nodig heeft om ze op het scherm weer te geven. Dit kan met behulp van arrays. Bijvoorbeeld als volgt:

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

Het zou veel handiger zijn als we één type hadden om alle informatie over een punt op te slaan: x, y, color. Als een dergelijk type niet bestaat in Java, kunt u het zelf maken.

Om dit te doen, schrijven we code voor een Pointklasse:

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

Nu kan de bovenstaande code worden herschreven als:

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

Laten we nu een methode aan de Pointklasse toevoegen die informatie over het object zal weergeven:

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

Nu Solutionziet de klas er zo uit:

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

We hebben vakkundig de coördinaten en kleurinformatie van het punt in de Pointklasse verborgen, samen met de methode die de status van het punt weergeeft.

Klassen zijn een manier om de complexiteit van het programma te beheersen. Een groot programma wordt minder complex als het wordt opgedeeld in veel kleine klassen.

4. Veranderlijke versus onveranderlijke objecten

Ooit bestudeerden we constanten op Java en kwamen tot een conclusie die niet erg geruststellend is. Met constanten kunt u ervoor zorgen dat variabelen niet worden gewijzigd, maar ze kunnen geen wijzigingen in de objecten waarnaar ze verwijzen, voorkomen.

Om dit probleem op te lossen, kwam Java met constante objecten. Of, zoals ze vaker worden genoemd, onveranderlijke objecten.

Trouwens, je kent al zo'n klasse, waarvan de objecten niet kunnen worden gewijzigd: String. Een Stringobject blijft voor altijd ongewijzigd nadat het is gemaakt. En hoe hebben de makers van Java dit bereikt?

Eerst Stringworden alle variabelen van de klasse verborgen, dwz gedeclareerd private.

Ten tweede kun je de klasse niet erven String: de klassedeclaratie bevat de finalmodifier.

Ten derde, en het meest interessant, alle methoden van de Stringklasse, waarvan je in theorie zou verwachten dat ze het bestaande object veranderen, veranderen het niet echt, maar retourneren in plaats daarvan een nieuw object.

De methode maakt bijvoorbeeld toUpperCase()alle letters in de tekenreeks in hoofdletters. Maar in plaats van het object waarop de methode wordt aangeroepen te wijzigen, retourneert het een nieuw Stringobject bestaande uit hoofdletters:

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

Dit is wat er in het geheugen zal zijn na het uitvoeren van deze code:

Dus voel je vrij om je strings door te geven aan welke methode dan ook: niemand zal ze veranderen.