streamalism.org

1. Áttekintés

Ebben a cikkben megvizsgáljuk az objektum-orientált programozás (OOP) fogalmait a Java-ban. Megbeszéljük osztályok, tárgyak, absztrakció, kapszulázás, öröklés és polimorfizmus.

2. Osztályok

Az osztályok az összes objektum kiindulópontjai, és ezeket az objektumok létrehozásának sablonjának tekinthetjük. Egy osztály általában tagmezőket, tag-módszereket és egy speciális konstruktor-módszert tartalmazna.

A konstruktort használjuk az osztály objektumainak létrehozására:

public class Car {// tagmezők private String type; privát húr modell; saját karakterlánc színe; privát int sebesség; // konstruktor public Car (karakterlánc típusa, karakterlánc modell, karakterlánc színe) {this.type = type; ez.modell = modell; ez.szín = szín; } // tag metódusok public int növelésSpeed ​​(int növekmény) {this.speed = this.speed + növekmény; adja vissza ezt.sebesség; } // ...}

Vegye figyelembe, hogy egy osztálynak több konstruktora lehet. Az órákról bővebben az osztályok cikkében olvashatunk.

3. Tárgyak

Az objektumok osztályokból jönnek létre, és az osztály példányainak hívják őket. Az osztályokból objektumokat hozunk létre konstruktoraik segítségével:

Autó veyron = új autó ("Bugatti", "Veyron", "bíbor"); Autókorvetta = új autó ("Chevrolet", "Corvette", "fekete"); 

Itt hoztuk létre az osztály két példányát Autó. Olvasson többet róluk tárgyaink cikkében.

4. Absztrakció

Az absztrakció a megvalósítás bonyolultságának elrejtését és az egyszerűbb felületek feltárását jelenti.

Ha egy tipikus számítógépre gondolunk, akkor csak a külső interfészt láthatjuk, amely a vele való interakcióhoz elengedhetetlen, míg a belső chipek és áramkörök el vannak rejtve a felhasználó elől.

Az OOP-ban az absztrakció azt jelenti, hogy elrejti a program összetett megvalósítási részleteit, és csak a megvalósítás használatához szükséges API-t teszi ki. A Java-ban az absztrakciót interfészek és absztrakt osztályok használatával érjük el.

Az absztrakcióról többet olvashatunk absztrakt osztály- és felületcikkekben.

5. Kapszulázás

A beágyazás egy objektum állapotának vagy belső reprezentációjának elrejtése az API fogyasztója elől és nyilvánosan hozzáférhető módszerek biztosítása az objektumhoz olvasási és írási hozzáféréshez. Ez lehetővé teszi a konkrét információk elrejtését és a belső megvalósításhoz való hozzáférés ellenőrzését.

Például egy osztály tagmezői el vannak rejtve más osztályok elől, és a tag metódusokkal érhetők el. Ennek egyik módja az összes adatmező elkészítése magán és csak a nyilvános tag módszerek:

public class Car {// ... privát int sebesség; public int getSpeed ​​() {return color; } public void setSpeed ​​(int sebesség) {this.sebesség = sebesség; } // ...}

Itt a mező sebesség segítségével kapszulázzák magán hozzáférés-módosító, és csak a public getSpeed ​​() és setSpeed ​​() mód. A hozzáférés-módosítókról bővebben a hozzáférés-módosítók cikkünkben olvashatunk.

6. Öröklés

Az öröklés az a mechanizmus, amely lehetővé teszi az egyik osztály számára, hogy az osztály öröklődésével megszerezze az összes tulajdonságot egy másik osztálytól. Az öröklődő osztályt gyermekosztálynak, az öröklött osztályt pedig szuperosztálynak vagy szülői osztálynak hívjuk.

A Java-ban ezt a szülőosztály kibővítésével tesszük. Így a gyermekosztály az összes tulajdonságot megkapja a szülőtől:

nyilvános osztályú autó meghosszabbítja a járművet {// ...}

Ha kiterjesztünk egy osztályt, akkor IS-A kapcsolatot alakítunk ki. A Autó EGY Jármű. Tehát, rendelkezik az a összes jellemzőjével Jármű.

Feltehetjük a kérdést, miért van szükségünk öröklésre? Ennek megválaszolásához vegyünk egy olyan járműgyártót, aki különböző típusú járműveket gyárt, például autókat, buszokat, villamosokat és teherautókat.

A munka megkönnyítése érdekében az összes járműtípus közös jellemzőit és tulajdonságait modulokká csomagolhatjuk (Java esetén osztály). Hagyhatjuk, hogy az egyes típusok örököljék és újra felhasználhassák ezeket a tulajdonságokat:

public class Jármű {private int kerekek; privát húr modell; public void start () {// a jármű elindításának folyamata} public void stop () {// a jármű leállításának folyamata} public void honk () {// alapértelmezett dudálást eredményez}}

A jármű típusa Autó mostantól örökölni fog a szülőtől Jármű osztály:

public class Autó kiterjeszti Jármű {private int numberOfGears; public void openDoors () {// az ajtók kinyitásának folyamata}}

A Java támogatja az egyszeri és a többszintű öröklést. Ez azt jelenti, hogy egy osztály nem terjedhet ki egynél több osztályból, de használhat hierarchiát:

a Public Class ArmoredCar kiterjeszti a Car {private boolean bulletProofWindows; public void remoteStartCar () {// ez a jármű egy távirányító használatával elindítható}}

Itt a ArmouredCar kiterjed Autó, és Autó kiterjed Jármű. Így, ArmouredCar tulajdonságokat örököl mindkettőtől Autó és Jármű.

Míg a szülő osztálytól örökölünk, egy fejlesztő felülírhatja a módszer megvalósítását a szülőtől is. Ez az eljárás felülírása.

A fenti példánkban a Jármű osztály, ott van a dudál() módszer. A Autó osztály kiterjesztése Jármű osztály felülírhatja ezt a módszert, és úgy valósíthatja meg, ahogy a honk előállítását szeretné:

nyilvános osztályú autó meghosszabbítja a járművet {// ... @Orride public void honk () {// autóspecifikus dudálást gyárt}}

Vegye figyelembe, hogy ezt futásidejű polimorfizmusnak is nevezik, amint azt a következő szakasz elmagyarázza. Az öröklésről bővebben olvashatunk Java öröklési, valamint öröklési és összetételi cikkekben.

7. Polimorfizmus

A polimorfizmus az OOP nyelv azon képessége, hogy a bemenetek típusától függően különböző módon dolgozza fel az adatokat. A Java-ban ez ugyanaz a metódusnév lehet, különböző metódus-aláírásokkal és különböző funkciókkal:

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

Ebben a példában láthatjuk, hogy a módszer olvas() három különböző formája van, különböző funkciókkal. Ez a fajta polimorfizmus statikus vagy fordítási idejű polimorfizmus, és módszer túlterhelésnek is nevezik.

Van futási idő ill dinamikus polimorfizmus, ahol a gyermekosztály felülírja a szülő módszerét:

public class GenericFile {private String name; // ... public String getFileInfo () {return "Generic File Impl"; }}

A gyermekosztály kiterjesztheti a GenericFile osztály és felülírja a getFileInfo () módszer:

az ImageFile nyilvános osztály kiterjeszti a GenericFile {private int height; privát int szélesség; // ... getters and setters public String getFileInfo () {return "Képfájl Impl"; }}

További információ a polimorfizmusról a Java-cikk polimorfizmusában.

8. Következtetés

Ebben a cikkben megismertük az OOP Java-val kapcsolatos alapvető fogalmait.

Az ebben a cikkben szereplő kódminták a Github oldalon érhetők el.