Objectgeoriënteerde programmeerconcepten in Java

1. Overzicht

In dit artikel gaan we in op Object-Oriented Programming (OOP) -concepten in Java. We zullen bespreken klassen, objecten, abstractie, inkapseling, overerving en polymorfisme.

2. Klassen

Klassen zijn het startpunt van alle objecten en we kunnen ze beschouwen als de sjabloon voor het maken van objecten. Een klasse bevat doorgaans ledenvelden, lidmethoden en een speciale constructormethode.

We zullen de constructor gebruiken om objecten van de klasse te maken:

openbare klasse Auto {// lidvelden privé Stringtype; privé String-model; private String kleur; privé int snelheid; // constructor public Car (String-type, String-model, String-kleur) {this.type = type; this.model = model; this.color = kleur; } // lid methoden openbaar int verhogenSpeed ​​(int increment) {this.speed = this.speed + increment; retourneer this.speed; } // ...}

Merk op dat een klasse meer dan één constructor kan hebben. We kunnen meer lezen over de lessen in ons klassenartikel.

3. Objecten

Objecten worden gemaakt op basis van klassen en worden instanties van de klasse genoemd. We maken objecten van klassen met behulp van hun constructors:

Car veyron = nieuwe auto ("Bugatti", "Veyron", "crimson"); Autokorvet = nieuwe auto ("Chevrolet", "Corvette", "zwart"); 

Hier hebben we twee instanties van de klas gemaakt Auto. Lees er meer over in ons objectenartikel.

4. Abstractie

Abstractie verbergt de complexiteit van de implementatie en legt eenvoudigere interfaces bloot.

Als we aan een typische computer denken, kan men alleen de externe interface zien, die het meest essentieel is voor interactie ermee, terwijl interne chips en circuits voor de gebruiker verborgen zijn.

In OOP betekent abstractie het verbergen van de complexe implementatiedetails van een programma, waarbij alleen de API wordt getoond die nodig is om de implementatie te gebruiken. In Java bereiken we abstractie door interfaces en abstracte klassen te gebruiken.

We kunnen meer lezen over abstractie in onze abstracte klasse- en interfaceartikelen.

5. Inkapseling

Inkapseling is het verbergen van de staat of interne representatie van een object voor de consument van een API en het verschaffen van openbaar toegankelijke methoden die zijn gebonden aan het object voor lees- en schrijftoegang. Dit maakt het mogelijk om specifieke informatie te verbergen en de toegang tot interne implementatie te controleren.

Ledenvelden in een klasse zijn bijvoorbeeld verborgen voor andere klassen en zijn toegankelijk via de lidmethoden. Een manier om dit te doen, is door alle gegevensvelden te maken privaat en alleen toegankelijk via de openbaar lid methoden:

openbare klasse Auto {// ... privé int snelheid; public int getSpeed ​​() {kleur terug; } public void setSpeed ​​(int snelheid) {this.speed = snelheid; } // ...}

Hier, het veld snelheid is ingekapseld met behulp van de privaat access modifier, en is alleen toegankelijk met de openbare getSpeed ​​() en setSpeed ​​() methoden. We kunnen meer lezen over toegangsmodificatoren in ons artikel over toegangsmodificatoren.

6. Erfenis

Overerving is het mechanisme waarmee een klasse alle eigenschappen van een andere klasse kan verwerven door de klasse te erven. We noemen de overervende klasse een onderliggende klasse en de overgeërfde klasse als de superklasse of bovenliggende klasse.

In Java doen we dit door de bovenliggende klasse uit te breiden. De kindklasse krijgt dus alle eigenschappen van de ouder:

openbare klasse Auto verlengt Voertuig {// ...}

Als we een klas uitbreiden, vormen we een IS-A-relatie. De Auto IS EEN Voertuig. Het heeft dus alle kenmerken van een Voertuig.

We kunnen de vraag stellen, waarom hebben we erfdeel nodig? Laten we om dit te beantwoorden eens kijken naar een autofabrikant die verschillende soorten voertuigen maakt, zoals auto's, bussen, trams en vrachtwagens.

Om het werk gemakkelijk te maken, kunnen we de gemeenschappelijke kenmerken en eigenschappen van alle voertuigtypen bundelen in een module (een klasse in het geval van Java). En we kunnen individuele typen die eigenschappen laten erven en hergebruiken:

openbare klasse Vehicle {private int wheels; privé String-model; public void start () {// het proces van het starten van het voertuig} public void stop () {// proces om het voertuig te stoppen} public void honk () {// produceert een standaard honk}}

Het voertuigtype Auto zal nu erven van de ouder Voertuig klasse:

openbare klasse Auto verlengt Voertuig {private int numberOfGears; public void openDoors () {// proces om de deuren te openen}}

Java ondersteunt enkelvoudige overerving en overerving op meerdere niveaus. Dit betekent dat een klasse zich niet rechtstreeks van meer dan één klasse kan uitstrekken, maar een hiërarchie kan gebruiken:

openbare klasse ArmoredCar breidt Car {private boolean bulletProofWindows; public void remoteStartCar () {// dit voertuig kan worden gestart met een afstandsbediening}}

Hier de Gepantserde auto strekt zich uit Auto, en Auto strekt zich uit Voertuig. Zo, Gepantserde auto erft eigenschappen van beide Auto en Voertuig.

Hoewel we erven van de bovenliggende klasse, kan een ontwikkelaar ook een methode-implementatie van de bovenliggende klasse overschrijven. Dit staat bekend als het overschrijven van een methode.

In ons bovenstaande voorbeeld van de Voertuig klasse, er is de toeteren () methode. De Auto klasse uitbreiding van de Voertuig class kan deze methode overschrijven en implementeren op de manier waarop het de honk wil produceren:

public class Auto breidt voertuig uit {// ... @Override public void honk () {// produceert autospecifieke honk}}

Merk op dat dit ook wel een runtime-polymorfisme wordt genoemd, zoals uitgelegd in de volgende sectie. We kunnen meer lezen over overerving in onze artikelen over overerving en overerving en samenstelling van Java.

7. Polymorfisme

Polymorfisme is het vermogen van een OOP-taal om gegevens op verschillende manieren te verwerken, afhankelijk van hun soorten invoer. In Java kan dit dezelfde methodenaam zijn met verschillende methodenhandtekeningen en verschillende functies uitvoeren:

public class TextFile breidt GenericFile uit {// ... public String read () {return this.getContent () .toString (); } public String read (int limit) {return this.getContent () .toString () .substring (0, limit); } public String lezen (int start, int stop) {return this.getContent () .toString () .substring (start, stop); }}

In dit voorbeeld kunnen we zien dat de methode lezen() heeft drie verschillende vormen met verschillende functionaliteiten. Dit type polymorfisme is statisch of compileertijd polymorfisme en wordt ook wel methode-overbelasting genoemd.

Er is ook runtime of dynamisch polymorfisme, waarbij de kindklasse de methode van de ouder overschrijft:

openbare klasse GenericFile {private String-naam; // ... public String getFileInfo () {return "Generic File Impl"; }}

Een kinderklasse kan het GenericFile class en overschrijf de getFileInfo () methode:

public class ImageFile breidt GenericFile {private int hoogte uit; private int breedte; // ... getters en setters public String getFileInfo () {return "Image File Impl"; }}

Lees meer over polymorfisme in ons artikel over polymorfisme in Java.

8. Conclusie

In dit artikel hebben we geleerd over de fundamentele basisconcepten van OOP met Java.

De codevoorbeelden in dit artikel zijn beschikbaar op Github.