Új hozzászólás Aktív témák

• #2059 modder aktív tag pvt.peter #2057

  Új Válasz 2013-05-09 12:13:03 #2059

  Új hozzászólás

  Összes hozzászólása itt Válaszok az összes hozzászólására itt Válaszok erre a hozzászólásra

  Privát üzenet küldése

  

  modder

  aktív tag

  válasz pvt.peter #2057 üzenetére

  Hali. Polimorfizmus (többalakúság, ugyanolyan ős típusú objektumok másképpen viselkedhetnek). Amikor több osztályod van, ami ugyanazokat a tulajdonságokat (metódusokat) definiálja, ezért közös ősből származik, de mégis minden osztály egy kicsit másképpen viselkedik, vagyis kicsit más az implementációjuk, viszont az interfészük (amit az osztály használója lát) megegyezik.

  Most hirtelen a Java JDBC API jut eszembe:

  //Create the connection using the static getConnection method
  Connection con = DriverManager.getConnection (connectionURL);
  
  //Create a Statement class to execute the SQL statement
  Statement stmt = con.createStatement();

  Itt a DriverManager egy factory osztály, ami olyan Connection példányt ad vissza, ami adatbázis specifikus a szerint, hogy milyen adatbázis típus szerepel a connection URL-ben. A Connection csak egy interfész, minden konkrét adatbázis JDBC driver a sajátját specifikálja, és a konkrét, con változóhoz kötött példány lehet, hogy mondjuk MysqlConnection típus lesz. Itt a lényeg az, hogy a MysqlConnection a Connection-ből származik, és felülírja a Connection metódusait.

  Ami fontos megjegyezni futás időben fog eldőlni, hogy melyik metódus fog meghívódni, mert fordításkor lehetetlen eldönteni a fenti kódrészletből, hogy a con változó konkrétan milyen osztály lesz.

  C++-ban explicite ki kell írnod a virtual kulcsszót a függvény elé. Ha nem teszed ki, akkor is felülírhatod a metódust, de nem biztos, hogy azt az eredményt fogod kapni, amit vársz. Például

  class A {
  public:
  void valami() { std::cout << "A"; }
  virtual void virt() { std::cout << "A"; }
  }
  
  class B : A {
  public:
  void valami() { std::cout << "B"; }
  void virt() { std::cout << "B"; }
  }

  A b = new B();
  b.valami(); // "A" fog kiíródni, mert valami() nem virtuális, tehát a változó "statikus" típusa alapján dől el, hogy melyik metódus fog meghívódni. A statikus típus pedig "A"

  B b = new B();
  b.valami(); // itt a statikus típus "B", tehát "B" fog kiírodóni.

  Ezzel szemben

  A b = new B();
  b.virt(); // itt "B" fog kiíródni azért, mert a virt() függvény virtuális. futás időben a virtuális függvény táblából a program megnézi, hogy melyik konkrét függvény hívódjon meg. Mindezt a b változó futásidejű (dinamikus) típusa alapján, ami itt "B"

  Heterogén kollekciókban szokták hasznát venni, amikor (mint az első példában) egy közöt ős van, ami szolgáltatja az interfészt, de többféle implementációt tárolsz egy tömbben vagy listában. Amikor végigiterálsz rajtuk, hogy meghívd mindegyiken valamelyik metódusát, nem kell foglalkoznod a konkrét típussal, ami nagyban leegyszerűsíti a programozó munkáját. Ez annyira az általános elvárt működés, hogy Javában minden metódus virtuális. Ha nem akarod, hogy valamelyiket felül lehessen írni, akkor a final kulcsszót kell elé tenni.

  Amikor egy osztályt kiterjeszthetőségre tervezel, ki kell választanod azokat a metódusait, amiket felül lehet majd írni, és virtuálissá teszed őket. Ezzel elég körültekintőnek kell lenned, mert egy felülírt virtuális metódus a származtatott osztályban el is ronthatja az alap működést.

• #2058 mgoogyi senior tag pvt.peter #2057

  Új Válasz 2013-05-09 12:04:10 #2058

  Új hozzászólás

  Összes hozzászólása itt Válaszok az összes hozzászólására itt Válaszok erre a hozzászólásra

  Privát üzenet küldése

  

  mgoogyi

  senior tag

  válasz pvt.peter #2057 üzenetére

  röviden:
  polimorf osztályoknál van értelme, amikor specializálod a működését az ősosztálynak és minden leszármazottat kezelhetsz úgy, mint ha az egy ősosztálybeli objektum lenne.
  pl. minden almát és körtét kezelhetsz gyümölcsként
  pl. Akkor van ennek haszna, mikor van egy rakás valamilyen gyümölcsöd mondjuk egy halmazban és együtt akarod kezelni őket, mert pl. az adott helyzetben számodra nem lényeg, hogy milyen specializált gyümölcsről van szó.

  Amikor örökölsz, akkor a virtuális függvények mindig befigyelnek!

  hosszan:

  class Gyumolcs
  {
  ...
  virtual void print() {printf("gyumolcs")}
  ...
  };
  
  class Alma() : public Gyumolcs
  {
  ...
  virtual void print() {printf("alma")}
  ...
  };
  
  class Korte() : public Gyumolcs
  {
  ...
  virtual void print() {printf("korte")}
  ...
  };
  
  Gyumolcs * a = new Alma();
  a->print(); //azt írja ki, hogy alma, pedig ez egy Gyumolcs pointer
  /*mivel: a virtuális függvényeknél futási időben dől el (dinamikusan), hogy mi hívódik (megnézi, hogy valójában milyen objektumról van szó és annak a függvényét hívja - a háttérben egyébként van az objektumnak egy virtuális táblája és abból nézi ki, hogy mit kell hívni)
  ha nem virtuális lenne a függvény, akkor fordítási időben (statikusan dőlne el, mit kell hívni és "gyumolcs" íródna ki)*/

Új hozzászólás Aktív témák