OOP fogalmak Java nyelven

A Java egyik legnagyobb erőssége az objektum-orientált programozás (OOP). Ez az oka annak, hogy ez a nyelv olyan népszerűvé vált, és bármilyen méretű projekthez kiválóan alkalmas. Mi az objektumorientált programozás? Ez nem varázslat, de varázslatosnak tűnhet, ha tényleg belevágsz. Az OOP arról szól, hogyan készítsd el a szoftveredet. Ez egy olyan fogalom, vagy inkább egy csomó oop-fogalom a Java-ban, amely lehetővé teszi bizonyos interakciók és kapcsolatok létrehozását a Java objektumok között a szoftverek hatékony fejlesztése és használata érdekében. A klasszikus OOP 3 + 1 fő fogalmat tartalmaz. Kezdjük a klasszikusokkal.

Egységbezárás

Az adatbeágyazás a belső adatok elrejtése a külvilág elől, és csak nyilvánosan hozzáférhető módszerekkel érhető el. Az mit jelent? Milyen adatok? Ki elől bujkál? Az elrejtés azt jelenti, hogy korlátozzuk a közvetlen hozzáférést egy osztály adattagjaihoz (mezőihez).

Hogyan működik a Java nyelven:

1. A mezőket priváttá teszik
2. Az osztály minden mezője két speciális metódust kap: egy gettert és egy settert. A Getter metódusok visszaadják a mező értékét. A beállító metódusok lehetővé teszik a mező értékének közvetett, de megengedett módon történő megváltoztatását.

Példa a beágyazásra Java kódban:

public class Student {
private int age;
private String name;

public int getAge() {
return age;
}

public void setAge(int age) {
this.age = age;
}

public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}

public class Test{
public static void main(String[] args) {
Student firstStudent = new Student();
firstStudent.setName("John");
// The name field is private, so you can no longer do this:  firstStudent.name = "John";
}
}

Miért érdemes kapszulát használni?

Ennek fő oka az, hogy megkönnyítse a kód megváltoztatását. Képzelje el, hogy jelentkezik egy jégkorongiskolába, és van egy HockeyStudent osztály két mezővel, amelyek tárolják a diák nevét és életkorát, amikor beiratkozott az iskolába. Valami ilyesmi:

public class HockeyStudent {
public String name;
public  int ageOfEnrollment;
}

Az ageOfEnrollment mező nyilvános, nincsenek getterek vagy setterek… Ezt az osztályt sok más osztály használja, és minden rendben volt, amíg valamelyik fejlesztő úgy döntött, hogy egyetlen int mező nem elég. Egyes jégkorongozók egy kohorszban majdnem egy évvel idősebbek társaiknál, ezért kényelmesebb lenne két csoportra osztani őket születésük hónapjától függően. Tehát az ageOfEnrollment mezőt módosítani kell egy int tömbre (int[][]) : az első szám a teljes évekre, a második a hónapokra vonatkozik. Most minden olyan kódot újra kell alakítania, amely a Student osztályt használja! De ha az Ön koraOfEnrollmentA mező privát, és vannak getterek és setterek, akkor minden könnyebb. Ha megváltozik a tanuló életkorának beállítására vonatkozó követelmény, csak frissítse a logikát a setAgeOfEnrollment() setter metódusban, és az osztályok gond nélkül folytathatják a Student használatát! Ez a példa kissé mesterkélt, de remélem, megmagyarázza, miért jó ötlet a tokozás használata.

Öröklés

Ez az elv gyakorlati tapasztalat nélkül is könnyebben érthető. Ne ismételd magad (SZÁRAZ) lehetne az öröklési koncepció mottója. Az öröklődés lehetővé teszi olyan utódosztály létrehozását, amely örökli a szülőosztály mezőit és metódusait anélkül, hogy újradefiniálná azokat. Persze, felülírhatod a szülő osztály mezőit és metódusait a gyermekosztályban, de ez nem feltétlenül szükséges. Sőt, új állapotokat és viselkedéseket is hozzáadhat a gyermekosztályhoz. A szülőosztályokat néha szuperosztályoknak vagy alaposztályoknak, a gyermekosztályokat pedig alosztályoknak nevezik. A Java extends kulcsszót az öröklődés elvének kódban való megvalósítására használják.

Hogyan működik a Java nyelven:

1. Hozza létre a szülőosztályt.
2. Hozzon létre egy gyermekosztályt az extends kulcsszó használatával.
3. A Child osztály konstruktorában használja a szuper(szülőmező1, szülőmező2, ...) metódust a szülő mezők beállításához.

Néhány szabály:

1. Egy osztálynak csak egy szülője lehet.
2. Egy szülői osztálynak több gyermekosztálya is lehet.
3. Egy gyermekosztálynak lehetnek saját gyermekosztályai.

Példa az öröklődésre Java kódban

Hozzunk létre egy Telefon osztályt.

public class Phone {
    int price;
    double weight;

// Constructor
public Phone(int price, double weight) {
        this.price = price;
        this.weight = weight;
    }

    void orderPhone(){
        System.out.println("Ordering phone...");
    }
}

Természetesen vannak különböző típusú telefonok, ezért hozzunk létre két gyermekosztályt: egyet az Android telefonokhoz, a másikat az iPhone-okhoz. Ezután hozzáadunk néhány olyan mezőt és metódust, amelyekkel a szülő nem rendelkezik. És a super() segítségével hívjuk meg a konstruktorokat, hogy inicializáljuk azokat a mezőket, amelyekkel a szülőosztály rendelkezik.

Példa az öröklődésre Java nyelven

public class Android extends Phone {

// Some new fields
String androidVersion;
int screenSize;

    String secretDeviceCode;

// Constructor
    public Android(int price, double weight, String androidVersion, int screenSize, String secretDeviceCode) {
        super(price, weight); // Android inherits Phone’s fields

        //this - reference to the current object
        //super - reference to the parent object

        this.androidVersion = androidVersion;
        this.screenSize = screenSize;
        this.secretDeviceCode = secretDeviceCode;
    }

	// New Android-specific method, does not exist in the Phone class
    void installNewAndroidVersion() {
        System.out.println("installNewAndroidVersion invoked...");

    }

}

public class IPhone extends Phone {

    boolean fingerPrint;

    public IPhone(int price, double weight, boolean fingerPrint) {
        super(price, weight);
        System.out.println("IPhone constructor was invoked...");
        this.fingerPrint = fingerPrint;
    }

    void deleteIPhoneFromDb() {
        System.out.println("deleteIPhoneFromDb invoked...");
    }

@Override // This is about polymorphism, see below
void orderPhone(){
        System.out.println("Ordering my new iPhone and deleting the old one...");
    }
}

Tehát ismétlem: Java-ban az öröklődés lehetővé teszi, hogy egy osztályt olyan gyermekosztályokkal bővítsünk, amelyek öröklik a szülőosztály mezőit és metódusait. Ez egy kiváló módja a kód újrafelhasználhatóságának.

Polimorfizmus

A polimorfizmus egy tárgy azon képessége, hogy különböző formákat öltsön, vagy inkább eltérő módon viselkedjen. A Java-ban a polimorfizmus általában akkor fordul elő, ha egy szülő osztály hivatkozást használnak egy utód osztály objektumra való hivatkozásra.

Mit jelent ez, és hogyan működik a Java nyelven:

Mi a polimorfizmus a Java nyelven? Ez általában azt jelenti, hogy ugyanazt a módszernevet használhatja különböző célokra. A Java-ban kétféle polimorfizmus létezik: a módszer felülbírálása (dinamikus polimorfizmus) és a módszer túlterhelése (statikus polimorfizmus).

Módszer felülbírálása

Felülírhatja a szülő osztály metódusát egy gyermekosztályban, és kényszerítheti azt, hogy más módon működjön. Hozzunk létre egy Zenész szülőosztályt play() metódussal.

Példa polimorfizmusra a Java kódban

public class Musician {
    String name;
    int age;

    // Default constructor
    public Musician() {
    }

    // Parameterized constructor
    public Musician(String name, int age) {
        this.name = name;
        this.age = age;
    }

    void play() {
        System.out.println("I am playing my instrument...");
    }
}

A különböző zenészek különböző hangszereket használnak. Hozzunk létre két gyermekosztályt: Zongorista és Hegedűs . A polimorfizmusnak köszönhetően mindegyik végrehajtja a play() metódus saját verzióját. Felülbíráláskor használhatja a @Override megjegyzést, de nem szükséges.

public class Pianist extends Musician {

    String favoritePianoType;

    public Pianist(String name, int age, String favoritePianoType) {
        super(name, age);
        this.favoritePianoType = favoritePianoType;
    }


    @Override
void play(){
        System.out.println("I am playing the piano...");
    }
}

A hegedűs lehet szólista vagy zenekari tag. Vegyük ezt figyelembe, amikor felülírjuk a play() metódusunkat.

public class Violinist extends Musician {
    boolean isSoloist;

public Violinist(String name, int age, boolean isSoloist) {
            super(name, age);
            this.isSoloist = isSoloist;
        }


    @Override
void play(){
if (isSoloist)
        System.out.println("I am playing the violin solo...");
else
System.out.println("I am playing the violin in an orchestra...");

    }
}

Hozzunk létre egy Demo osztályt, amelyben három objektumot fogunk létrehozni, egy-egy példányt a korábban létrehozott osztályokból. Meglátjuk milyen eredményt érünk el.

public class Demo {
  public static void main(String[] args) {
  Musician musician = new Musician();
  Violinist violinist = new Violinist("John", 32, true);
  Pianist pianist = new Pianist("Glen", 30, "Acoustic");

  System.out.println("Musician said:");
  musician.play();
  System.out.println("Violinist said:");
  violinist.play();
  System.out.println("Pianist said:");
  pianist.play();
    }
}

Íme, amit kapunk:

Musician said:
I am playing my instrument...
Violinist said:
I am playing the violin solo…
Pianist said:
I am playing the piano...

Minden hegedűs és zongorista zenész, de nem minden zenész brácsás vagy zongorista. Ez azt jelenti, hogy használhatja a zenész játékmódját, ha nem kell újat létrehoznia. Vagy hívhatja a szülő metódusát a gyermektől a szuper kulcsszó használatával. Tegyük ezt meg a zongorista kódjában:

public class Pianist extends Musician {

    String favoritePianoType;

    @Override
    void play(){
        super.play();
        System.out.println("I am playing the piano...");
    }
}

Most hívjuk meg a Main() metódusunkat a Demo osztályban. Íme az eredmény:

Musician said:
I am playing my instrument...
Violinist said:
I am playing the violin solo...
Pianist said:
I am playing my instrument...
I am playing the piano...

A módszer túlterhelése

A módszer túlterhelése azt jelenti, hogy ugyanazon az osztályon belül különböző, azonos nevű metódusokat használunk. Különbözniük kell a paramétereik számát, sorrendjét vagy típusát tekintve. Tegyük fel, hogy egy zongorista tud játszani akusztikus és elektromos zongorán. Elektromos játékhoz a zenésznek áramra van szüksége. Hozzunk létre két különböző play() metódust. Az első paraméterek nélkül, akusztikus zongorához, a második pedig olyan paraméterrel, amely jelzi, hogy van-e áram.

public class Pianist extends Musician {

    String name;
    int age;
    String favoritePianoType;

    @Override
    void play(){
        super.play();
        System.out.println("I am playing the piano...");
    }
    void play(boolean isElectricity){
        if (isElectricity) {
            System.out.println("The electricity is on.");
            System.out.println("I am playing the piano...");
        }
        else System.out.println("I can't play this without electricity.");
    }
}

Egyébként az első play() metódus a második play(boolean) metóduson belül a következő módon használható:

void play(boolean isElectricity){
        if (isElectricity) {
            System.out.println("The electricity is on.");
            play();
        }
        else System.out.println("I can't play this without electricity.");
    }

Adjunk hozzá néhány sort a Demo osztályunkhoz, hogy demonstráljuk túlterhelésünket:

public class Demo {
    public static void main(String[] args) {

        Musician musician = new Musician();
        Violinist violinist = new Violinist("John", 23, true);
        Pianist pianist = new Pianist("Glen", 30, "Acoustic");

        System.out.println("Musician said:");
        musician.play();
        System.out.println("Violinist said:");
        violinist.play();
        System.out.println("Pianist said:");
        pianist.play();
        System.out.println("The pianist will now try the electric piano:");
        pianist.play(true);
        System.out.println("The electricity has been shut off. Now when trying the electric piano, the pianist says:");
        pianist.play(false);
    }
}

Íme az eredmény:

Musician said:
I am playing my instrument...
Violinist said:
I am playing the violin solo...
Pianist said:
I am playing my instrument...
I am playing the piano...
The pianist will now try the electric piano:
The electricity is on.
I am playing my instrument...
I am playing the piano...
The electricity has been shut off. Now when trying the electric piano, the pianist says:
I can't play this without electricity.

A Java paraméterei és az objektum típusa alapján tudja, hogy melyik metódust kell használni. Ez polimorfizmus.

Absztrakció

Amikor meghatározunk egy osztályt, megpróbálunk valami modellt felépíteni. Tegyük fel például, hogy egy MyRacer nevű videojátékot írunk, különböző versenyautóval. A játékos választhat ezek közül egyet, majd később frissítheti vagy vásárolhat egy másikat. Szóval… Mi az az autó? Egy autó elég bonyolult dolog, de ha egy versenyvideójátékot próbálunk létrehozni (nem egy vezetési szimulátorral), akkor nem kell leírnunk a benne található több ezer sebességváltót és tömítést. Szükségünk van a modelljére, a végsebességére, a manőverezhetőségi jellemzőire, az ára, a színe… És talán ennyi is elég. Ez egy autó modellje a játékunkhoz. Tegyük fel, hogy később a MyRacer 2-ben úgy döntünk, hogy hozzáadunk olyan abroncsokat, amelyek befolyásolják a kezelhetőséget az úton. Itt a modell más, mert több részletet adtunk hozzá. hagyjuk s az adatabsztrakciót úgy definiálja, mint egy objektum fontos (vagy szükséges) jellemzőinek azonosítását, és figyelmen kívül hagyja a lényegtelen részleteket. Az absztrakciónak különböző szintjei vannak. Például, ha Ön egy busz utasa, tudnia kell, hogyan néz ki és hová megy, de nem kell tudnia, hogyan kell vezetni. Ha Ön buszsofőr, nem kell tudnia, hogyan kell új buszt létrehozni – csak azt kell tudnia, hogyan kell vezetni. De ha Ön buszgyártó, akkor az absztrakció alacsonyabb szintjére kell mennie, mert a busz tervezésének részletei nagyon fontosak Önnek. Remélem érted mire gondolok. tudnod kell, hogyan néz ki a buszod és hova megy, de nem kell tudni, hogyan kell vezetni. Ha Ön buszsofőr, nem kell tudnia, hogyan kell új buszt létrehozni – csak azt kell tudnia, hogyan kell vezetni. De ha Ön buszgyártó, akkor az absztrakció alacsonyabb szintjére kell mennie, mert a busz tervezésének részletei nagyon fontosak Önnek. Remélem érted mire gondolok. tudnod kell, hogyan néz ki a buszod és hova megy, de nem kell tudni, hogyan kell vezetni. Ha Ön buszsofőr, nem kell tudnia, hogyan kell új buszt létrehozni – csak azt kell tudnia, hogyan kell vezetni. De ha Ön buszgyártó, akkor az absztrakció alacsonyabb szintjére kell mennie, mert a busz tervezésének részletei nagyon fontosak Önnek. Remélem érted mire gondolok.

Hogyan működik a Java nyelven:

Építsünk négy absztrakciós szintet a Java-ban, vagy inkább az OOP-ban – a legalacsonyabbtól (a legspecifikusabb) a legmagasabbig (a legelvontabb).

1. Az absztrakció legalacsonyabb szintje egy konkrét objektum. Ez egy olyan entitás, amelynek jellemzői egy adott osztályhoz tartoznak. Meghatározott mezőértékei vannak

2. Az objektumok létrehozására szolgáló sablon egy osztály. Ez egy hasonló tulajdonságú és belső szerkezetű objektumok halmazának leírása.

3. Az absztrakt osztály egy osztálykészlet jellemzőinek absztrakt leírása (más osztályok általi öröklődés sablonjaként működik). Magas absztrakciós szinttel rendelkezik, így lehetetlen közvetlenül egy absztrakt osztályból objektumokat létrehozni. Csak az absztrakt osztályok gyermekosztályai használhatók objektumok létrehozására. Egy absztrakt osztály tartalmazhat metódusokat implementációval, de ez nem követelmény.

4. Az interfész a Java programozási nyelv konstrukciója, amely csak absztrakt nyilvános metódusokat és statikus konstans mezőket (final static) tartalmaz. Más szóval sem absztrakt osztályok, sem interfészek nem használhatók objektumok generálására.

BTW, Java 8-ban vagy újabb verziókban az interfészeknek nemcsak absztrakt metódusai és konstansai lehetnek, hanem alapértelmezett és statikus metódusai is. A Java-ban egy interfész definiál egy viselkedést, míg egy absztrakt osztályt használnak a hierarchia létrehozására. Egy interfészt több osztály is megvalósíthat.

Példa interfészre Java kódban

interface Human {
	public void struggle();
	public void protect();
}

interface Vulcan {
	int angleOfPointyEars;
	public void turnOffEmotions(boolean isOn);
	public void telepathy();
}

Egynél több interfészt is megvalósíthat

The Spock class implements Human and Vulcan {
public void struggle() {
System.out.println("I am struggling...");
}
	public void protect() {
System.out.println("You are under my protection!”);
}
public void turnOffEmotions(boolean isOn){
If (isOn) {
System.out.println("I am turning off my emotions.");
isOn= !isOn;
}
}
	public void telepathy() {
System.out.println("Connecting to your brain...");
}

}

Kezdő diákok számára ez lefedi a Java objektum-orientált programozás összes fő fogalmát. A 4 fő OOP-elv mellett a Java asszociációval, összesítéssel és összetétellel is rendelkezik. Nevezheti őket "további OOP-elveknek". Megérdemlik a külön cikküket.