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 variable
is een variabele die een verwijzing naar een object opslaat, en method
is 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 variable
is een variabele die een verwijzing naar een object opslaat, en field
is een instantievariabele (veld).
2. new
exploitant
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 Class
is de naam van de klasse van de variable
variabele 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 arguments
is 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 console
variabele 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)
Scanner
console
In de tweede regel roepen we de nextInt()
methode op het Scanner
object aan, met behulp van de console
variabele, die een verwijzing naar het Scanner
object opslaat.
Voorbeelden van het maken van objecten:
Code | Beschrijving |
---|---|
|
Maak een String voorwerp |
|
Maak een Scanner voorwerp |
|
Maak een int[] : een container met 10 int elementen |
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 s
een verwijzing op naar een instantie van de String
klasse.
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 100
en 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 Point
klasse:
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 Point
klasse 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 Solution
ziet 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 Point
klasse 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 String
object blijft voor altijd ongewijzigd nadat het is gemaakt. En hoe hebben de makers van Java dit bereikt?
Eerst String
worden alle variabelen van de klasse verborgen, dwz gedeclareerd private
.
Ten tweede kun je de klasse niet erven String
: de klassedeclaratie bevat de final
modifier.
Ten derde, en het meest interessant, alle methoden van de String
klasse, 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 String
object 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.
GO TO FULL VERSION