Java-klassen en -objecten

1. Overzicht

In deze korte tutorial kijken we naar twee basisbouwstenen van de programmeertaal Java: klassen en objecten. Het zijn basisconcepten van Object Oriented Programming (OOP), die we gebruiken om real-life entiteiten te modelleren.

In OOP, klassen zijn blauwdrukken of sjablonen voor objecten. We gebruiken ze om soorten entiteiten te beschrijven.

Aan de andere kant, objecten zijn levende wezens, gemaakt op basis van klassen. Ze bevatten bepaalde toestanden binnen hun vakgebied en presenteren bepaald gedrag met hun methoden.

2. Klassen

Simpel gezegd, een klasse vertegenwoordigt een definitie of een type object. In Java kunnen klassen velden, constructors en methoden bevatten.

Laten we een voorbeeld bekijken met een eenvoudige Java-klasse die een Auto:

class Car {// velden String type; String model; String kleur; int snelheid; // constructor Car (String-type, String-model, String-kleur) {this.type = type; this.model = model; this.color = kleur; } // methoden int verhogenSpeed ​​(int increment) {this.speed = this.speed + increment; retourneer this.speed; } // ...} 

Deze Java-klasse vertegenwoordigt een auto in het algemeen. We kunnen elk type auto uit deze klasse maken. We gebruiken velden om de staat vast te houden en een constructor om objecten uit deze klasse te maken.

Elke Java-klasse heeft standaard een lege constructor. We gebruiken het als we geen specifieke implementatie bieden zoals hierboven. Hier is hoe de standaardconstructor zou zoeken naar onze Auto klasse:

Auto(){} 

Deze constructor initialiseert eenvoudig alle velden van het object met hun standaardwaarden. Strings worden geïnitialiseerd op nul en gehele getallen tot nul.

Nu heeft onze klasse een specifieke constructor omdat we willen dat onze objecten hun velden hebben gedefinieerd wanneer we ze maken:

Auto (String-type, String-model) {// ...} 

Samenvattend, we schreven een les die een auto definieert. De eigenschappen ervan worden beschreven door velden, die de status van objecten van de klasse bevatten, en het gedrag wordt beschreven met behulp van methoden.

3. Objecten

Terwijl klassen worden vertaald tijdens het compileren, objecten worden tijdens runtime gemaakt van klassen.

Objecten van een klasse worden instanties genoemd en we maken en initialiseren ze met constructors:

Autofocus = nieuwe auto ("Ford", "Focus", "rood"); Auto auris = nieuwe auto ("Toyota", "Auris", "blauw"); Autogolf = nieuwe auto ("Volkswagen", "Golf", "groen"); 

Nu hebben we verschillende gemaakt Auto objecten, allemaal uit één klasse. Dit is waar het allemaal om draait, om de blauwdruk op één plek te definiëren en deze vervolgens op veel plaatsen meerdere keren te hergebruiken.

Tot nu toe hebben we er drie Auto objecten, en ze zijn allemaal geparkeerd omdat hun snelheid nul is. We kunnen dit veranderen door onze snelheid verhogen methode:

focus.increaseSpeed ​​(10); auris.increaseSpeed ​​(20); golf.increaseSpeed ​​(30); 

Nu hebben we de staat van onze auto's veranderd - ze rijden allemaal met verschillende snelheden.

Bovendien kunnen en moeten we toegangscontrole voor onze klasse, zijn constructors, velden en methoden definiëren. We kunnen dit doen door toegangsmodificatoren te gebruiken, zoals we in de volgende sectie zullen zien.

4. Toegang tot modificatoren

In de vorige voorbeelden hebben we toegangsmodificatoren weggelaten om de code te vereenvoudigen. Door dit te doen, hebben we eigenlijk een standaard pakket-privé-modifier gebruikt. Die modifier geeft toegang tot de klasse vanuit elke andere klasse in hetzelfde pakket.

Meestal gebruiken we een openbaar modificator voor constructeurs om toegang vanuit alle andere objecten toe te staan:

openbare auto (type string, model string, kleur string) {// ...} 

Elk veld en elke methode in onze klasse had ook toegangscontrole moeten hebben gedefinieerd door een specifieke modifier. Klassen hebben meestal openbaar modifiers, maar we hebben de neiging om onze velden te behouden privaat.

Velden bevatten de staat van ons object, daarom willen we de toegang tot die staat regelen. We kunnen er een paar houden privaat, en anderen openbaar. Dit bereiken we met specifieke methodes genaamd getters en setters.

Laten we eens kijken naar onze klas met volledig gespecificeerde toegangscontrole:

openbare klasse Car {privé String-type; // ... public Car (String-type, String-model, String-kleur) {// ...} public String getColor () {retourkleur; } public void setColor (String kleur) {this.color = color; } public int getSpeed ​​() {retoursnelheid; } // ...} 

Onze klas is gemarkeerd openbaar, wat betekent dat we het in elk pakket kunnen gebruiken. De constructor is ook openbaar, wat betekent dat we een object van deze klasse binnen elk ander object kunnen maken.

Onze velden zijn gemarkeerd privaat, wat betekent dat ze niet rechtstreeks vanuit ons object toegankelijk zijn, maar we bieden er toegang toe via getters en setters.

De type en model- velden hebben geen getters en setters, omdat ze interne gegevens van onze objecten bevatten. We kunnen ze tijdens de initialisatie alleen via de constructor definiëren.

Bovendien is de kleur kan worden geopend en gewijzigd, terwijl snelheid is alleen toegankelijk, maar kan niet worden gewijzigd. We dwongen snelheidsaanpassingen af ​​via gespecialiseerde openbaar methoden verhogen snelheid () en verminder snelheid().

Met andere woorden, we gebruiken toegangscontrole om de staat van het object in te kapselen.

5. Conclusie

In dit artikel hebben we twee basiselementen van de Java-taal, klassen en objecten, doorgenomen en laten zien hoe en waarom ze worden gebruikt. We hebben ook de basisprincipes van toegangscontrole geïntroduceerd en het gebruik ervan gedemonstreerd.

Om andere concepten van de Java-taal te leren, raden we aan om als volgende stap te lezen over overerving, het super-sleutelwoord en abstracte klassen.

De volledige broncode voor het voorbeeld is beschikbaar op GitHub.