Beágyazás Java nyelven

Szia! A mai leckét a Java-ban való kapszulázásnak szenteljük, és rögtön a kapuból példákkal kezdjük:) Itt van egy közönséges szódaadagoló gép . Lenne egy kérdésem: hogyan működik? Próbáljon meg részletes választ adni: Honnan származik a szóda? Hogyan tartható fenn a belső hőmérséklet? Hol tárolják a jeget? Honnan tudja a gép, hogy melyik szirupot kell hozzáadni? Valószínűleg nem kap választ ezekre a kérdésekre. Oké, talán nem mindenki használja ezeket a gépeket. Jelenleg nem annyira népszerűek. Próbáljunk meg egy másik példát. Valami, amit biztosan sokszor használsz minden nap. Ó, van egy ötletem! Mondja el, hogyan működik a Google keresőművek. Pontosan hogyan keres információt a beírt szavakról? Miért ezek az eredmények vannak a csúcson, és miért nem mások? Bár mindennap használja a Google-t, valószínűleg nem tudja. De ez nem számít. Végül is ezt nem kell tudnia. Használhat keresőmotort anélkül, hogy átgondolná, hogyan működik. Vásárolhat szódát egy gépről anélkül, hogy tudná, hogyan épül fel. Vezethet autót anélkül, hogy elmélyülne a belső égésű motor működésében, és anélkül, hogy ismerné a középiskolai fizikát. Ez mind lehetséges az objektum-orientált programozás egyik fő elvének: a tokozásnak köszönhetően. A témával kapcsolatos különböző cikkek olvasása során biztosan találkozott két elterjedt programozási fogalommal: a beágyazás és az információrejtés. Amint megtörténik, különböző emberek értik ezt a szót tokozás” különböző dolgokat jelent. Mindkét kifejezést megfejtjük, hogy teljes megértése legyen. A programozásban az eredeti jelentéseA kapszulázás az adatok és az adatokkal való munkavégzés módszereinek egy csomagban ("kapszulában") történő egyesítése volt. A Java nyelvben a beágyazó csomag az osztály . Az osztály adatokat (mezőket) és módszereket is tartalmaz az adatokkal való munkavégzéshez. Ez nyilvánvalónak tűnhet számodra, de más programozási paradigmákban minden másképp van elrendezve. Például a funkcionális programozásban az adatokat szigorúan elválasztják az adatműveletektől. Az objektum-orientált programozásban (OOP) a programok kapszulákból (osztályokból) állnak, amelyek adatokból és adatokkal való munkavégzésre szolgáló függvényekből állnak.

Most beszéljünk az információk elrejtéséről

Hogyan használhatunk mindenféle összetett mechanizmust anélkül, hogy megértenénk, hogyan épülnek fel vagy hogyan működnek? Egyszerű: készítőik egyszerű és kényelmes felületeket biztosítottak. Egy szódagépen az interfész az előlapon található gombok. Egy gombbal kiválaszthatja a csésze méretét. A szirupot egy második gombbal választja ki. Egy harmadik felelős a jég hozzáadásáért. És csak ennyit kell tenned. Nem mindegy, hogyan néz ki belülről a gép. A lényeg az, hogy úgy van megtervezve, hogy a felhasználó három gomb megnyomásával kapjon szódát. Ugyanez vonatkozik egy autóra is. Nem mindegy, mi történik odabent. A lényeg az, hogy a jobb oldali pedál megnyomására az autó előre halad, a bal pedál megnyomására pedig lassul. Ez az információrejtés lényege. egy program 'belsejei' rejtve vannak a felhasználó elől. Az ilyen információk feleslegesek vagy szükségtelenek a felhasználó számára. A felhasználónak végeredményre van szüksége, nem belső folyamatra. Példaként vessünk egy pillantást aJármű osztály:

public class Vehicle {

   public void gas() {

       /* Some complicated things happen inside a car.
       As a result, it moves forward */
   }

   public void brake() {

       /* Some complicated things happen inside a car.
       As a result, it slows down */
   }

   public static void main(String[] args) {

       Vehicle vehicle = new Vehicle();

       // How everything looks to the user

       // Press one pedal, the car moves
       vehicle.gas();

       // Press the other pedal, the car brakes
       vehicle.brake();
   }
}

Így van elrejtve a megvalósítás egy Java programban. Akárcsak a való életben: a felhasználót interfésszel (módszerekkel) látják el. Egy programban, ha autóra van szüksége egy művelet végrehajtásához, egyszerűen meghívja a kívánt metódust. Ami ezeken a módszereken belül történik, az felesleges. A lényeg, hogy minden úgy működjön, ahogy kell. Itt a megvalósítás elrejtéséről beszéltünk. A Java is rejti az adatokat. A getterekről és szetterekről szóló leckében írtunk róla , de nem árt egy emlékeztető. Például van egy macska osztályunk:

public class Cat {

   public String name;
   public int age;
   public int weight;

   public Cat(String name, int age, int weight) {
       this.name = name;
       this.age = age;
       this.weight = weight;
   }

   public Cat() {
   }

   public void sayMeow() {
       System.out.println("Meow!");
   }


}

Talán emlékszel egy korábbi leckéből, hogy mi a probléma ezzel az osztállyal? Ha nem, emlékezzünk vissza. A probléma az, hogy adatai (mezői) mindenki számára nyitottak. Egy másik programozó könnyen létrehozhat egy névtelen macskát, amelynek súlya 0 és -1000 éves:

public static void main(String[] args) {

   Cat cat = new Cat();
   cat.name = "";
   cat.age = -1000;
   cat.weight = 0;

}

Ebben a helyzetben gondosan nyomon követheti, hogy valamelyik kollégája hoz-e létre érvénytelen állapotú objektumokat, de sokkal jobb lenne, ha még az érvénytelen objektumok létrehozásának lehetőségét is kiküszöbölné. Az adatok elrejtését a következők segítségével érjük el:

1. hozzáférés módosítók ( privát, védett, alapértelmezett csomag );
2. getterek és szetterek.

Segítségükkel ellenőrizzük, hogy valaki negatív életkort próbál-e adni a macskának. Mint korábban említettük, a különböző tokozással foglalkozó cikkek szerzői tulajdonképpen a kapszulázásra (az adatok és módszerek kombinálására) vagy az információrejtésre, vagy mindkettőre utalnak. A Java mindkét mechanizmussal rendelkezik (más OOP nyelveknél ez nem feltétlenül igaz), így az utolsó lehetőség a leghelyesebb.

A kapszulázás számos fontos előnnyel jár:

1. Az objektum helyes állapotának figyelése. Erre adtunk példákat fent: a setternek és a privát módosítónak köszönhetően a programunkat a 0 súlyú macskák ellen biztosítottuk.


2. Felhasználóbarát felület. Csak a módszereket hagyjuk a felhasználó rendelkezésére. A felhasználónak egyszerűen fel kell hívnia őket, hogy eredményt érjen el. És nincs szükség a működésük részleteibe mélyedni.


3. A kódmódosítások nem érintik a felhasználókat. Minden változtatást a metódusokon belül hajtunk végre. Ez nem érinti a felhasználókat: a vehicle.gas() -t írták a gáz alkalmazására, és ezt fogják tenni továbbra is. Az a tény, hogy a gas() metóduson belül változtattunk valamit, láthatatlan marad: mint korábban, egyszerűen megkapják a kívánt eredményt.