Csavarhúzós feladat Készíts egy Csavarhuzo nevű osztályt, ami csavarhúzót reprezentál.…
- User
Csavarhúzós feladat Készíts egy Csavarhuzo nevű osztályt, ami csavarhúzót reprezentál. Az adattagokat, vala- mint az elvárt metódusokat az alábbi ábrán láthatjuk. Ügyelj a megfelelő láthatóságok hasz- nálatára! Csavarhuzo
- meret: int
- Csavarhuzo(meret: int, fej: Csavarfej) + getMeret() : int
- getCsavarFej(): Csavarfej
- toString(): String 1
- ábra. Csavarhúzó osztálydiagram
csavarfej
Extends <> Csavarfej EGYHORNYU PHILLIPS IMBUSZ CserelhetoFejuCsavarhuzo
- fejMeret : int
- egyhornyuFej : boolean - phillipsFej : boolean
- imbuszFej : boolean
- CserelhetoFejuCsavarhuzo(meret: int, fejMeret: int, csavarFej: CsavarFej) + fejElhagy(melyik: String): void
- fejCsere(melyikre: String): boolean
- getMeret(): int Csavarfej Készíts egy Csavarfej nevű publikus felsorolást, az UML alapján! Csavarhúzó A Csavarhuzo és Csavarfej közötti asszociáció az ábráról is leolvashatóan adattag formá- jában valósul meg. Konstruktor • Kettő paramétert váró konstruktor: várja a csavarhúzó méretét, valamint egy csavarfejet, ezeket az azonos nevű adattagok értékének állítsd be.
"Készíts egy Csavarfej nevű publikus felsorolást, az UML alapján! Csavarhúzó A Csavarhuzo és Csavarfej közötti asszociáció az ábráról is leolvashatóan adattag formájában valósul meg." -> Ezt hogyan kell megcsinálni?
- Assistant
Az utasítások alapján két részt kell megvalósítani: a
Csavarfejfelsorolást és aCsavarhuzoosztályt. Először készítsük el aCsavarfejfelsorolást, ami meghatározza a csavarhúzók lehetséges fejtípusait, mint például EGYHORNYU, PHILLIPS, IMBUSZ:public enum Csavarfej { EGYHORNYU, PHILLIPS, IMBUSZ }Most készítsük el a
Csavarhuzoosztályt. Ebben az osztályban van egy adattag a mérethez (meret) és egy a csavarfejhez (fej), amely aCsavarfejtípusú. A konstruktornak ezeket az értékeket be kell állítania az objektum létrehozásakor. Ezen kívül implementálnunk kell a lekérdező függvényeket (getMeret(),getCsavarFej()) és egytoString()metódust is, amely szöveges formában reprezentálja az objektumot:public class Csavarhuzo { private int meret; private Csavarfej fej; public Csavarhuzo(int meret, Csavarfej fej) { this.meret = meret; this.fej = fej; } public int getMeret() { return meret; } public Csavarfej getCsavarFej() { return fej; } @Override public String toString() { return "Csavarhuzo{" + "meret=" + meret + ", fej=" + fej + '}'; } }Ebben az implementációban a
Csavarhuzoosztály tartalmazza a specifikált adattagokat és metódusokat. AtoString()metódus egyszerűen visszaad egy sztringet, amely információt nyújt a csavarhúzóról (mérete és feje típusa).Ez az osztály és az enum együtt kiszolgálja az UML diagram alapján definiált követelményeket, biztosítva, hogy a
Csavarhuzoobjektumok mérete és feje könnyedén beállítható, lekérdezhető és szöveges formában reprezentálható legyen. - User
És ez a sor elengedhetetlen? Vagy ez miért nincs benne az UML ábrában: private Csavarfej fej; Illetve ez a mondat mit jelent? "A Csavarhuzo és Csavarfej közötti asszociáció az ábráról is leolvashatóan adattag formájában valósul meg." Az ábrán a csavarhúzó osztályból egy nyíl mutat az <> Csavarfej-hez. A nyílra az van írva, hogy "# csavarfej".
- Assistant
Az UML ábrában a
private Csavarfej fej;adattag valóban nem szerepel explicit módon, de az asszociáció aCsavarhuzoosztály és aCsavarfejenumeráció között jelzi, hogy a két osztály között kapcsolat van. Amikor az UML diagramon egy osztályból nyíl mutat egy másikra, az általában asszociációt jelez, azaz valamilyen kapcsolatot vagy kölcsönhatást a két elem között. Itt a "# csavarfej" megjegyzés arra utal, hogy aCsavarhuzoosztálynak van egycsavarfejtípusú referenciaadattagja, ami aCsavarfejtípust használja.Azért, hogy elérjük ezt a kapcsolatot (vagy asszociációt) a valós kódunkban, szükségünk van arra, hogy bevezessünk egy adattagot a
Csavarhuzoosztályon belül, ami tárol egyCsavarfejtípusú értéket. Ez történik aprivate Csavarfej fej;sor esetében. Ennek az adattagnak a bevezetése nem egyszerűen egy implementációs döntés, hanem közvetlenül leköveti az UML diagramon látható kapcsolatot.Az, hogy "A Csavarhuzo és Csavarfej közötti asszociáció az ábráról is leolvashatóan adattag formájában valósul meg." kifejezés azt jelenti, hogy a Csavarhuzo osztály és a Csavarfej enumeráció közötti kapcsolat egy konkrét adattagban (ebben az esetben a
fejadattagban) ölt testet. Az adattag formájában való megvalósulás biztosítja, hogy minden egyesCsavarhuzoobjektum társítható legyen egy adottCsavarfejértékkel, azaz minden csavarhúzónak lesz egy feje, amit az enumeráció definiál.Röviden: A diagramból és a követelményekből adódóan készítjük el a kódot úgy, hogy a modellezett kapcsolat implementálásra kerüljön az adattagokon keresztül. Az adattagok és metódusok elnevezése és a kapcsolatok megvalósítása közvetlenül az ábrán látható jelek és kapcsolódások alapján történik, ami biztosítja a kód és a tervezés közötti összhangot.
- User
A "CserelhetoFejuCsavarhuzo"-ból mutat egy nyíl "Csavarhuzo"-ba, és rá van írva, hogy "extends". Ez mit jelent, ezt hogyan kell megvalósítani kódban?
- Assistant
Az "extends" kulcsszó az UML diagramon azt jelenti, hogy öröklődési kapcsolat áll fenn a két osztály, a
CserelhetoFejuCsavarhuzoés aCsavarhuzoközött. Konkrétan, ez azt jelenti, hogy aCserelhetoFejuCsavarhuzoosztály egy leszármazottja vagy al osztálya aCsavarhuzoosztálynak. Ez azt jelenti, hogy aCserelhetoFejuCsavarhuzoörökli aCsavarhuzoösszes publikus és védett (protected) adattagját és metódusát, így a már definiált viselkedésre építhetünk tovább, specifikusabb funkcionalitást adva az új osztálynak, amely a cserelehetőséget kezeli.Java kódban az öröklődés úgy valósítható meg, hogy az osztálydeklarációban az "extends" kulcsszót követően megadjuk a szülőosztály nevét. Például:
public class CserelhetoFejuCsavarhuzo extends Csavarhuzo { // Adattagok private int fejMeret; private boolean egyhornyuFej; private boolean phillipsFej; private boolean imbuszFej; // Konstruktor public CserelhetoFejuCsavarhuzo(int meret, int fejMeret, Csavarfej csavarFej) { super(meret, csavarFej); // Szülőosztály konstruktorának meghívása this.fejMeret = fejMeret; // Példányosításkor alapértelmezés szerint csak a konstruktorban megadott csavarfej // típusa lesz elérhető. További logika szükséges az egyes csavarfej típusok kezelésére. } // További metódusok, például a fejcsere logikájának implementációja public void fejElhagy(String melyik) { // Implementáció } public boolean fejCsere(String melyikre) { // Implementáció return true; // vagy false, a logikától függően } // Esetleg további metódusok és logika }Ebben a példában a
CserelhetoFejuCsavarhuzoosztály "extends" kulcsszóval kiterjeszti aCsavarhuzoosztályt, így örökölve annak minden nem privát adattagját és metódusát. Egyedi adattagok és/vagy metódusok hozzáadásával bővíthetjük a leszármazott osztály funckionalitását, például itt hozzáadjuk a fejcsere logikát és az ahhoz szükséges adattagokat.Figyelembe kell venni, hogy ha a szülőosztálynak nincsen paraméter nélküli konstruktora (például mivel csak olyan konstruktorokat definiáltunk, amelyek paramétereket igényelnek), akkor a leszármazott osztálynak a konstruktorában explicit módon meg kell hívnia a szülőosztály egyik konstruktorát a
superkulcsszó segítségével, ahogy a példa is mutatja. - User
Oké, de ez miért jobb, mintha csak simán létre kellene hoznom a "CserelhetoFejuCsavarhuzo" osztályt, és megmondani (hivatkozni egy adattagra), hogy public class CserelhetoFejuCsavarhuzo {
//ha szuksegunk van a toString metodusra miert nem csak egy meghivjuk? Miért kell az "extends Csavarhuzo"? Csavarhuzo.toString();
}
Illetve hogyan tér el ettől az "implements"?
- Assistant
A
CserelhetoFejuCsavarhuzoosztály öröklése aCsavarhuzoosztálytól (azaz azextendshasználata) több előnnyel is jár az egyszerűen hivatkozásnál (azaz ha csak egy adattagban tárolnánk egyCsavarhuzopéldányt). Nézzük meg ezeket az előnyöket:-
Kódújrafelhasználás: Az öröklődés lehetővé teszi, hogy újrahasználjuk a szülőosztály metódusait és adattagjait a leszármazott osztályban anélkül, hogy újra kellene őket írnunk. Tehát ami már a
Csavarhuzoosztályban meg van valósítva (pl.getMeret(),getCsavarFej(),toString()), az automatikusan része lesz aCserelhetoFejuCsavarhuzoosztálynak is. -
Polimorfizmus: A leszármazott osztályt kezelhetjük mint a szülőosztály egy példányát is. Ez lehetővé teszi többek között, hogy különböző típusú objektumokat ugyanazon az interfészen keresztül kezeljük, aminek köszönhetően rugalmasabbá és könnyebben bővíthetővé válik a kód.
-
Felülírás: Meg tudjuk változtatni (felül tudjuk írni) a szülőosztály bizonyos metódusainak viselkedését saját, specifikus implementációval a leszármazott osztályban. Például a
toString()metódus felülírásával adhatunk vissza részletesebb információt aCserelhetoFejuCsavarhuzoobjektumokról.
Az "implements"-sel szemben, ami azt jelenti, hogy egy osztály megvalósít egy vagy több interfészt, az "extends" kulcsszót öröklődésre használjuk. Az interfész egy olyan szerződés, amit az osztályoknak teljesíteniük kell. Egy interfész csak metódusdeklarációkat tartalmaz (Java 8 előtt szigorúan csak azokat, Java 8-től kezdődően default metódusokat és statikus metódusokat is tartalmazhatnak), és nem tartalmaz implementációkat az osztályoknak meg kell valósítania (
implement) az összes abban deklarált metódust.Tehát míg az "extends" egy létező osztály kiterjesztése, addig az "implements" egy szerződés megvalósítása. Mindkettő a kód újrafelhasználását és rugalmasságát célozza, de különböző eszközökkel és különböző helyzetekben.
-
- User
Cserélhető fejű csavarhúzó A cserélhető fejű csavarhúzókhoz alapvetően jár mindhárom fejtípus (ám ezeket el is hagyhat- juk),melyeketaegyhornyuFej, phillipsFej, imbuszFejreprezentál(aváltozóigaz, ha az adott fej még rendelkezésre áll, hamis, ha már elhagytuk). Mivel alapból jár mindhárom fej a cserélhető fejű csavarhúzókhoz, ezért az adattagok értéke kezdetben legyen igaz. Konstruktor • Három paramétert váró konstruktor: várja a csavarhúzó méretét (a fejjel együtt), a cse- rélhető fej méretét, valamint egy csavarfejet, ezeket az azonos nevű adattagok értékének állítsd be.
- Assistant
A feladatleírás alapján egy cserélhető fejű csavarhúzó osztályt fogunk létrehozni, ami a
Csavarhuzoosztály kiterjesztésével valósul meg. ACserelhetoFejuCsavarhuzoosztálynak lesznek saját adattagjai is, amelyek reprezentálják az egyes cserélhető fejek rendelkezésre állását. Szükségünk lesz egy konstruktorra is, ami inicializálja az osztályt, beleértve az adattagokat is az alapértelmezett értékekkel (mindhárom fej rendelkezésre áll).Itt egy példa implementációra, hogyan nézhet ki ez az osztály:
public class CserelhetoFejuCsavarhuzo extends Csavarhuzo { private int fejMeret; private boolean egyhornyuFej = true; private boolean phillipsFej = true; private boolean imbuszFej = true; public CserelhetoFejuCsavarhuzo(int meret, int fejMeret, Csavarfej csavarFej) { super(meret, csavarFej); // Meghívjuk a szülőosztály konstruktorát this.fejMeret = fejMeret; // Az egyhornyuFej, phillipsFej és imbuszFej értékek alapértelmezetten true, tehát minden fej // rendelkezésre áll kezdetben. } // Lekérdező függvények a fejek rendelkezésre állásához public boolean vanEgyHornyufeje() { return egyhornyuFej; } public boolean vanPhillipsfeje() { return phillipsFej; } public boolean vanImbuszfeje() { return imbuszFej; } // További metódusok, mint például a fej elhagyása vagy csere public void fejElhagy(String melyikFej) { switch (melyikFej.toLowerCase()) { case "egyhornyú": egyhornyuFej = false; break; case "phillips": phillipsFej = false; break; case "imbusz": imbuszFej = false; break; default: System.out.println("Ismeretlen fejtípus: " + melyikFej); } } // Felülírhatjuk a toString() metódust, ha szeretnénk több információt adni a csavarhúzóról @Override public String toString() { return "CserelhetoFejuCsavarhuzo{" + "meret=" + getMeret() + ", fejMeret=" + fejMeret + ", egyhornyuFej=" + egyhornyuFej + ", phillipsFej=" + phillipsFej + ", imbuszFej=" + imbuszFej + '}'; } }Ebben az implementációban a kezdeti állapotban minden egyes fej (egyhornyú, Phillips, imbusz) rendelkezésre áll, azaz a
trueérték került beállításra mint alapértelmezett. A konstruktorban meghívjuk a szülőosztály konstruktorát asuper(meret, csavarFej)hívással, majd beállítjuk a cserélhető fej méretét.Figyelembe véve a feladat egyéb részeit, további logikát kell implementálni a fejek cseréjéhez és kezeléséhez, pl. a
fejElhagymetódus már kezeli, amit a feladatra konkretizálva adott példában láthatunk. - User
"super(meret, csavarFej);" Ezt a sort el tudnád magyarázniM
- Assistant
Természetesen, örömmel!
Amikor egy osztály egy másik osztálytól örököl (
extendshasználata Java nyelvben), akkor az al osztály (gyermek osztály) képes hozzáférni a szülő osztály (szuper osztály) adattagjaihoz és metódusaihoz. Asuperkulcsszó különleges szerepet tölt be ebben az öröklődési viszonyban: lehetővé teszi a gyermek osztály számára, hogy hívja a szülő osztályának konstruktorait, metódusait, illetve hozzáférjen az adott adattagjaihoz (amennyiben azok elérhetőek az adott kontextusban).A
super(meret, csavarFej);sor, amelyet aCserelhetoFejuCsavarhuzoosztály konstruktorában találunk, a szülő osztály, vagyis aCsavarhuzokonstruktorának hívása. Ez pontosan azt jelenti, hogy közvetlenül meghívjuk aCsavarhuzoosztály konstruktorát, ami két paramétert vár: egyinttípusúmeretet és egyCsavarfejtípusúcsavarFejet.Ez a hívás kötelező, mert a
Csavarhuzoosztályban a két paraméteres konstruktor eltárolja és beállítja ezeket az értékeket aCsavarhuzoobjektum létrehozásakor. Mivel aCserelhetoFejuCsavarhuzoosztály aCsavarhuzo-ból örököl, szükség van a szülő osztály állapotának megfelelő inicializálására is, ami itt a méret és a csavarfej adattagok beállítását foglalja magában.Röviden, a
super(meret, csavarFej);sor meghívja a szülő osztály (Csavarhuzo) konstruktorát az al osztály (CserelhetoFejuCsavarhuzo) konstruktora során, hogy biztosítsa, aCsavarhuzomegfelelően inicializálva legyen aCserelhetoFejuCsavarhuzopéldányosításakor. Ez egy gyakori és szükséges minta a Java nyelvű öröklődés során, amennyiben a szülő osztálynak nincs paraméter nélküli konstruktora, vagy ha szeretnénk a szülő osztály bizonyos konstruktorát kifejezetten meghívni adott paraméterekkel. - User
Tehát akkor elmondható, hogy super(meret, csavarFej);-al "//az adott csavarfej meretet beallitom"?
- Assistant
Igen, általánosan fogalmazva, a
super(meret, csavarFej);hívással a szülő osztály konstruktorát meghívva beállítjuk az adott csavarhúzó méretét és típusát (csavarfejét) az öröklő osztály, vagyis aCserelhetoFejuCsavarhuzopéldányosításakor. Ez a sor biztosítja, hogy aCsavarhuzoosztály, mint szülőosztály, megfelelően inicializálódjon a szükséges adatokkal (mérettel és csavarfej típussal), amikor aCserelhetoFejuCsavarhuzo, mint leszármazott osztály egy példánya létrejön.Ez tehát azt jelenti, hogy ezen a ponton konkrétan beállításra kerülnek a csavarhúzó "fizikai" jellemzői az öröklődés mechanizmusán keresztül, ami lehetővé teszi, hogy a gyermek osztály példányai automatikusan rendelkezzenek a szülő osztályban meghatározott tulajdonságokkal és viselkedéssel (amennyiben azokat nem írjuk felül).
- User
Tehát akkor ez a super(meret, csavarFej); azt csinálja, mintha azt mondanám, hogy Csavarhuzo.meret = meret; Csavarhuzo.fej = csavarFej;
- Assistant
Majdnem pontosan így van, de fontos különbséget tenni a pontos működés megértése érdekében:
A
super(meret, csavarFej);hívás során nem közvetlenül az adattagokhoz "Csavarhuzo.meret = meret; Csavarhuzo.fej = csavarFej;" írással történő hozzárendelés történik, hanem a szülő osztály (Csavarhuzo) konstruktorának meghívása, ami végzi el ezeknek a mezőknek a beállítását a saját kontextusában.Amikor egy
CserelhetoFejuCsavarhuzopéldányt hozol létre, és meghívod asuper(meret, csavarFej);sorát a konstruktorában, tulajdonképpen aCsavarhuzoosztály konstruktorát hívod meg azzal a két paraméterrel, amit aCserelhetoFejuCsavarhuzokonstruktora kap. Ebben a kontextusban asuper(...);hívás jelenti azt, hogy "mint a jelenlegi objektum szülőosztályának egy példánya, hívd meg a szülő konstruktorát ezekkel a paraméterekkel".Ez a mechanizmus lehetővé teszi a
Csavarhuzoosztály számára, hogy saját logikája szerint inicializálja az adattagjait (meretésfej), amelyek ezután aCserelhetoFejuCsavarhuzopéldányban is be lesznek állítva, mivel ez az osztály örökli aCsavarhuzotulajdonságait.Tehát a korábbi megjegyzésemhez képest egy kis finomítás:
- A
super(meret, csavarFej);sor nem egyenértékű azzal, mintha közvetlenül írnánk az adattagokhoz a szülőosztályban. Helyette ez a konstruktor meghívásának a Java nyelvben elfogadott módja, ami az inicializációt végzi el az osztályhierarchiában "felfelé" haladva, biztosítva, hogy minden szülőosztály megfelelően inicializálódjon.
- A
- User
" super(meret, csavarFej); //csavarhuzo konstruktort meghivom, az adott csavarfej meretet es a csavarfejet beallitom" Ekkor ez így már pontosabb magyarázat?
- Assistant
Igen, ez a magyarázat már pontosabb és helyesen tükrözi a
super(meret, csavarFej);sor működését. Ezzel a hívással valóban aCsavarhuzoosztály konstruktorát hívod meg aCserelhetoFejuCsavarhuzoosztály konstruktorából, és átadod neki a szükséges paramétereket (a csavarhúzó méretét és a csavarfej típusát), amiket aztán az ő konstruktorában beállít a megfelelő adattagoknak.Ez a hívás biztosítja, hogy a
Csavarhuzobase (alap) osztály inicializálódjon a megadott értékekkel, amikor egyCserelhetoFejuCsavarhuzopéldányt hozol létre, így a leszármazott osztály rendelkezni fog minden örökölt tulajdonsággal és viselkedéssel, ami a szülő osztályban definiált. - User
Az fejCsere metódus működése: paraméterben kapunk egy szöveget (amely az alábbiak egyike: "egyhornyu", "phillips", "imbusz"), majd a beérkező szöveg alapján cseréljük le a fejet. Amire mindenképpen figyelni kell: • Amennyiben a jelenlegi és az új fej megegyezik, ne történjen semmi, térjünk vissza ha- missal.
- Assistant
Mivel a
fejCseremetódus működésének részletezéséhez szükség van aCsavarfejenumeráció és aCserelhetoFejuCsavarhuzoosztály egyes attribútumainak ismeretére, először definiáljuk ezt az enumerációt és az osztályt a már korábban említett adattagokkal. Most viszont kibővítjük aCserelhetoFejuCsavarhuzoosztályt afejCseremetódussal, ami a feladat kérésének megfelelően működik.Először is, nézzük meg a
Csavarfejenumerációt és aCserelhetoFejuCsavarhuzoosztályt:public enum Csavarfej { EGYHORNYU, PHILLIPS, IMBUSZ }Majd a
CserelhetoFejuCsavarhuzoosztályt kibővítjük afejCseremetódussal:public class CserelhetoFejuCsavarhuzo extends Csavarhuzo { // További adattagok és a konstruktor itt maradhatnak változatlanok // A fejCsere metódus implementációja public boolean fejCsere(String melyikre) { // Először is, ellenőrizzük, hogy a kívánt csavarfej típusa rendelkezésre áll-e switch (melyikre.toLowerCase()) { case "egyhornyu": if (this.getCsavarFej() == Csavarfej.EGYHORNYU) return false; // Ha megegyezik a jelenlegivel, ne csinálj semmit if (vanEgyHornyufeje()) { this.fej = Csavarfej.EGYHORNYU; // Csere return true; } break; case "phillips": if (this.getCsavarFej() == Csavarfej.PHILLIPS) return false; if (vanPhillipsfeje()) { this.fej = Csavarfej.PHILLIPS; // Csere return true; } break; case "imbusz": if (this.getCsavarFej() == Csavarfej.IMBUSZ) return false; if (vanImbuszfeje()) { this.fej = Csavarfej.IMBUSZ; // Csere return true; } break; } return false; // Ha nem rendelkezünk a kívánt fej típussal vagy nem volt változás, akkor hamissal térünk vissza } // Lekérdező függvények és egyéb osztály részletei... }Fontos megjegyzés, hogy a fenti példakódban feltételeztük, hogy a
Csavarhuzoosztályban van egyCsavarfej fej;adattag, aminek a típusa aCsavarfejenumeráció, és egygetCsavarFej()lekérdező függvény, ami visszaadja ennek az adattagnak az értékét. Továbbá, feltételeztük, hogy azvanEgyHornyufeje(),vanPhillipsfeje(), ésvanImbuszfeje()valamilyen logikával ellenőrzik, hogy a kívánt fej típusok rendelkezésre állnak-e még. Ezeket a részleteket is ki kell tölteni a teljes kód elkészítésekor. - User
Az fejCsere metódus működése: paraméterben kapunk egy szöveget (amely az alábbiak egyike: "egyhornyu", "phillips", "imbusz"), majd a beérkező szöveg alapján cseréljük le a fejet. Amire mindenképpen figyelni kell: • Amennyiben a jelenlegi és az új fej megegyezik, ne történjen semmi, térjünk vissza ha- missal. • Amennyiben a beállítani kívánt fejet már elhagytuk (az ezt reprezentáló logikai változó hamis), ne történjen semmi, térjünk vissza hamissal. • Amennyiben a jelenlegi fej nem egyezik meg az új fejjel, és az új fej rendelkezésre áll, cseréljük le azt (az örökölt csavarfej adattag beállításával).
this.fej is red.
- Assistant
Rendben, figyelembe véve a fenti magyarázatot és a "this.fej is red" jelzését, úgy tűnik, az osztálytervezésre és a kódszerkezetre vonatkozóan pontosításra van szükség.
Először is, az öröklődési struktúrában és az adattagok elérésében valószínűleg egy kisebb zavar van. Ebben az esetben, ha az adattag (
fej) a szülőosztályban (Csavarhuzo) van és azt privát láthatósággal rendelkezik, akkor közvetlenül nem férhetünk hozzá athis.fejmezőhöz a gyermekosztályban (CserelhetoFejuCsavarhuzo). A helyes megközelítés az lenne, ha a szülőosztályban (Csavarhuzo) biztosítanánk egy védett vagy nyilvános setter metódust (setCsavarFej()), amivel beállíthatjuk afejadattag értékét, vagy ha a hozzáférési láthatóságát megváltoztatnánk oly módon, hogy az alsószintű osztályokból elérhető legyen (példáulprotected-re állítani).Implementáljuk a
setCsavarFej()metódust aCsavarhuzoosztályban:public class Csavarhuzo { private int meret; private Csavarfej fej; public Csavarhuzo(int meret, Csavarfej fej) { this.meret = meret; this.fej = fej; } // Az adattagok lekérdezése public int getMeret() { return meret; } public Csavarfej getCsavarFej() { return fej; } // Csavarfej beállítása protected void setCsavarFej(Csavarfej ujFej) { this.fej = ujFej; } }Ezután a
CserelhetoFejuCsavarhuzoosztályban módosíthatjuk afejCseremetódust az alábbi módon, hogy figyelembe vegyük az újratervezett hozzáférési stratégiát:public boolean fejCsere(String melyikre) { Csavarfej ujFej; switch (melyikre.toLowerCase()) { case "egyhornyu": ujFej = Csavarfej.EGYHORNYU; break; case "phillips": ujFej = Csavarfej.PHILLIPS; break; case "imbusz": ujFej = Csavarfej.IMBUSZ; break; default: return false; // Nem ismert fej } // Ellenőrizzük, hogy a jelenlegi fej megegyezik-e az újjal if (this.getCsavarFej() == ujFej) { return false; } // Ellenőrizzük, hogy az új fej rendelkezésre áll-e if (!fejRendelkezesreAll(ujFej)) { return false; // Ha a kívánt fej nincs rendelkezésre, nem történik csere } // Fejcsere this.setCsavarFej(ujFej); return true; } // A fejRendelkezesreAll metódus ellenőrzi, hogy a kicserélni kívánt fej rendelkezésre áll-e private boolean fejRendelkezesreAll(Csavarfej ujFej) { switch (ujFej) { case EGYHORNYU: return this.egyhornyuFej; case PHILLIPS: return this.phillipsFej; case IMBUSZ: return this.imbuszFej; default: return false; } }Ebben a példában, a
setCsavarFej(Csavarfej ujFej)metódus segítségével változtatjuk meg a csavarfej értékét. A védett láthatóság (protected) biztosítja, hogy a metódus aCsavarhuzoosztály leszármazottaiban elérhető legyen, beleértve aCserelhetoFejuCsavarhuzoosztályt is. - User
• Amennyiben a jelenlegi fej nem egyezik meg az új fejjel, és az új fej rendelkezésre áll, cseréljük le azt (az örökölt csavarfej adattag beállításával).
Ezt hogy csinálom meg? Nem csinálhatok olyat, hogy setCsavarFej, ilyen nincs az UML diagramban.
De emlékeztetőül, itt a teljes feladat.
Csavarhúzós feladat Készíts egy Csavarhuzo nevű osztályt, ami csavarhúzót reprezentál. Az adattagokat, vala- mint az elvárt metódusokat az alábbi ábrán láthatjuk. Ügyelj a megfelelő láthatóságok hasz- nálatára! Csavarhuzo
- meret: int
- Csavarhuzo(meret: int, fej: Csavarfej) + getMeret() : int
- getCsavarFej(): Csavarfej
- toString(): String 1
- ábra. Csavarhúzó osztálydiagram
csavarfej
Extends <> Csavarfej EGYHORNYU PHILLIPS IMBUSZ
CserelhetoFejuCsavarhuzo
- fejMeret : int
- egyhornyuFej : boolean - phillipsFej : boolean
- imbuszFej : boolean
- CserelhetoFejuCsavarhuzo(meret: int, fejMeret: int, csavarFej: CsavarFej) + fejElhagy(melyik: String): void
- fejCsere(melyikre: String): boolean
- getMeret(): int
Csavarfej Készíts egy Csavarfej nevű publikus felsorolást, az UML alapján! Csavarhúzó A Csavarhuzo és Csavarfej közötti asszociáció az ábráról is leolvashatóan adattag formá- jában valósul meg. Konstruktor • Kettő paramétert váró konstruktor: várja a csavarhúzó méretét, valamint egy csavarfejet, ezeket az azonos nevű adattagok értékének állítsd be. Metódusok A kért getterek és szetterek az elvárásuknak megfelelően működjenek! A toString metódus térjen vissza egy szöveggel, az alábbiak szerint: • Amennyiben egyhornyú a csavarfej, térjen vissza a "hagyomanyos feju csavarhuzo" szö- veggel. • Amennyiben phillips fejű a csavarhúzó, térjen vissza a "csillagfeju csavarhuzo" szöveggel. • Amennyiben imbusz fejű a csavarhúzó, térjen vissza a "imbuszfeju csavarhuzo" szöveggel. Cserélhető fejű csavarhúzó A cserélhető fejű csavarhúzókhoz alapvetően jár mindhárom fejtípus (ám ezeket el is hagyhat- juk),melyeketaegyhornyuFej, phillipsFej, imbuszFejreprezentál(aváltozóigaz, ha az adott fej még rendelkezésre áll, hamis, ha már elhagytuk). Mivel alapból jár mindhárom fej a cserélhető fejű csavarhúzókhoz, ezért az adattagok értéke kezdetben legyen igaz. Konstruktor • Három paramétert váró konstruktor: várja a csavarhúzó méretét (a fejjel együtt), a cse- rélhető fej méretét, valamint egy csavarfejet, ezeket az azonos nevű adattagok értékének állítsd be. Metódusok A fejElhagy metódus működése: a kapott szöveg alapján (amely az alábbiak egyike: "egy- hornyu", "phillips", "imbusz") az adott fejhez tartozó logikai változót állítsa hamisra. Arra nem kell felkészülni, hogy olyan csavarfejet hagyunk el, ami éppen a csavarhúzón található, ez a valóságban sem fordul elő. Az fejCsere metódus működése: paraméterben kapunk egy szöveget (amely az alábbiak egyike: "egyhornyu", "phillips", "imbusz"), majd a beérkező szöveg alapján cseréljük le a fejet. Amire mindenképpen figyelni kell: • Amennyiben a jelenlegi és az új fej megegyezik, ne történjen semmi, térjünk vissza ha- missal. • Amennyiben a beállítani kívánt fejet már elhagytuk (az ezt reprezentáló logikai változó hamis), ne történjen semmi, térjünk vissza hamissal. • Amennyiben a jelenlegi fej nem egyezik meg az új fejjel, és az új fej rendelkezésre áll, cseréljük le azt (az örökölt csavarfej adattag beállításával). Definiáld felül a getMeret metódust. Mivel a csavarfej cserélhető, ezért annak mérete nem számít bele a csavarhúzó méretébe. Ennek megfelelően működjön a méretet visszaadó függvény. A konstruktorban érkező méret a csavarhúzó teljes mérete.
- Assistant
Figyelembe véve a feladat részletes leírását, láthatjuk, hogy valóban van némi zavar az "implements" és "extends" használatában, és a
setCsavarFej()funkciónak való hivatkozás kapcsán.Ha nem lehet közvetlenül a
setCsavarFej()metódust használni aCsavarhuzoosztályban afejadattag beállítására - mivel ez nem része az eredeti leírásnak -, ebben az esetben a megközelítésnek máshogy kell történnie. Tekintettel arra, hogy a szülő osztályban (Csavarhuzo) nincs említve a setter metódus, és örököljük afejadattagot valamilyen formában aCserelhetoFejuCsavarhuzoosztályba - az öröklés alapján - az új fej cseréje az öröklődés és a polimorfizmus segítségével történhet.Ezt elérhetjük például úgy, hogy felüldefiniáljuk a
getCsavarFej()metódust, és így minden csavarfej-csere esetén újrainicializáljuk aCsavarhuzoobjektumot az új fejparaméterrel, ha ez szükséges.Tekintsünk egy lehetséges megközelítést a
CserelhetoFejuCsavarhuzoosztály számára a zavar elkerülése érdekében, ami megfelel az UML diagram és a feladat leírásának:public class CserelhetoFejuCsavarhuzo extends Csavarhuzo { private boolean egyhornyuFej = true; private boolean phillipsFej = true; private boolean imbuszFej = true; public CserelhetoFejuCsavarhuzo(int meret, Csavarfej csavarFej) { super(meret, csavarFej); } public boolean fejCsere(String melyikre) { boolean fejRendelkezesreAll = false; switch (melyikre.toLowerCase()) { case "egyhornyu": fejRendelkezesreAll = egyhornyuFej; break; case "phillips": fejRendelkezesreAll = phillipsFej; break; case "imbusz": fejRendelkezesreAll = imbuszFej; break; } if (!fejRendelkezesreAll || getCsavarFej().toString().toLowerCase().equals(melyikre)) { return false; } // Ha az új fej rendelkezésre áll, és nem egyezik a jelenlegivel, akkor létrehozunk egy új Csavarhuzo objektumot ezzel a fejjel // Figyelem: Ez csak egy illusztratív példa. A Csavarhuzo osztályban nem valósítható meg így közvetlenül, mivel szükséges lenne a fej adattag beállítását lehetővé tevő mechanizmus. Csavarfej ujFej = Csavarfej.valueOf(melyikre.toUpperCase()); super.setCsavarFej(ujFej); // feltételezve, hogy van ilyen metódus, ami valójában nem része a feladatnak return true; } // További metódusok implementálása szükséges private void fejElhagy(String melyik) { switch(melyik.toLowerCase()) { case "egyhornyu": egyhornyuFej = false; break; case "phillips": phillipsFej = false; break; case "imbusz": imbuszFej = false; break; } } }Fontos kiemelni, hogy a fenti kódpélda egy lehetséges megközelítést mutat be, amely azonban elfogadja a
setCsavarFej(ujFej);hívást, ami a kérdés alapján nem tűnik lehetségesnek, mivel nincs felvázolva az UML diagramban.Valójában, ha a
Csavarhuzokonstruktorát kell használnunk fej cseréjéhez, akkor az újCsavarhuzopéldányosítása, vagy aCsavarhuzoosztály módosítása érdekében szükséges egy belső logika az osztályban, ami lehetővé teszi a csavarfej cseréjét, ami nem része a feladathoz definiált specifikációknak. A feladat úgy tűnik, több információt vagy részletesebb magyarázatot igényel ahhoz, hogy tisztázni lehessen, hogyan kívánták a fej cseréjének mechanizmusát pontosan implementálni.