A InfoWiki wikiből

Magasszintű Programozási Nyelvek II.

Objektum-orientált programozás

Hernyák Zoltán

Az OOP története

Az Objektum Orientált Programozás (O.O.P.) elveit Alan Kay fektette le diplomamunkájában, 1969-ben. Miután a Xerox Palo Alto-i kutatóközpontjában kezdett el dolgozni, folytatta és befejezte az alapelvek kidolgozását 1972-ben.

 

Megtervezett egy programozási nyelvet, melyet Smalltalk-nak nevezett el. Ez az első és máig is létező objektum-orientált programozási nyelv, amelynek napjainkban is készülnek újabb és újabb változatai, de az alapelvek mindvégig ugyanazok maradtak.

Egy másik területen is úttörő munkát végzett: szerinte a személyi számítógépnek grafikus felhasználói felülettel kell rendelkeznie és a fő beviteli egysége az egér kell legyen. A felhasználói felület a felhasználó ikonokon, menürendszereken, ablakokon kell, hogy alapuljon.

Alan Kay 1973-ban egy hordozható számítógépet álmodott meg, amit Dynabook-nak neveztek el. Ez egy könyv méretű, hordozható számítógép, ami vezeték nélküli hálózati csatlakoztatást, jó minőségű színes képernyőt és igen nagy számítási teljesítményt foglalt volna magába. A terv ugyan terv maradt, de Kay meggyőzte a Xerox kutatási vezetőit, hogy dolgozzanak az elképzelésén. Végül összeállították az akkoriban rendelkezésre álló csúcstechnológiából az Alto névre keresztelt gépet, ami valójában egy miniszámítógép volt 256 KiB memóriával, egérrel, cserélhető merevlemezes háttértárral. Grafikus felületű operációs rendszere szöveget és képeket is képes volt megjeleníteni képernyőjén, sőt hálózati képességekkel is felruházták: az első modemes munkaállomásnak tekinthetjük. Kay a hardver megálmodása után szoftvereket is tervezett, amelyek a mai grafikus felületen futó alkalmazások ősének tekinthetőek.

A Windows 3.1-ben már megtalálhatjuk Alan Kay elképzeléseit.

Az Objektum Orientált Programozás alapelvei

Az OOP paradigma során a programozási nyelvnek alkalmaznia kell az OOP mindhárom alapelvét:

• Egységbezárás: az objektum-osztályban egyetlen egységbe kell tudni zárni az objektum adatait (mezőit), és az azokat kezelő műveleteket (metódusok). Fejlettebb nyelveken lehetőség van a műveleteket operátorok formájában is megvalósítani.
• Öröklődés: amennyiben egy objektum-osztály már kifejlesztésre került, egy hozzá hasonló osztály kifejlesztését lehessen ezen osztály alapján elkezdeni. Ezen továbbfejlesztett osztály eleve tartalmazza az ősének minden mezőjét és metódusát.
• Sokalakúság: amennyiben egy továbbfejlesztett osztályban egy, az ősétől örökölt metódust felülírunk, átalakítunk, a változatlan formában örökölt metódusok képesek legyenek ezen új verziót automatikusan használni. Ezt jellemzően a virtuális metódusok segítségével szokták támogatni a programozási nyelvek.

Az alapelvek megoldása nincs szabályozva, ezért az OOP nyelvek között szintaktikai különbségek rejlenek. Ezen kívül több OOP nyelv a fenti elveken túlmutató, hasznos fejlesztéseket is tartalmaz. A C# az egyik legbővebb képességekkel rendelkező OOP nyelv, mely a szintaktika és a szemantika szempontjából is nagyon letisztult megoldásokat tartalmaz. Alapos megismerése után más OOP nyelveken programozva sok teljesen megegyező, vagy nagyon hasonló megoldásokkal találkozhatunk, így a C# OOP képességeit tanulmányozva nagyon jó alapozást kaphatunk ebben a témakörben.

Az OOP nyelvek osztályozása

Az objektum-orientált programozás bizonyos alapelvek meglétét feltételezik a választott programozási nyelven. Ezen elvek összeegyeztethetőek a hagyományos imperatív, eljárás-orientált programozási nyelvek elveivel. Ezért nagyon gyakori az, hogy egy már meglévő hagyományos programozási nyelv következő verziójába, az elvek közé bevették az OOP alapelveket is. Az így létrejött programozási nyelv egyszerre hordozza az imperatív és az OOP jellegét.

Ennek megfelelően három szintet különböztetünk meg:

• Hagyományos programozási nyelv: nem alkalmazza az OOP, csak az eljárás-orientált programozási nyelvek elveit. Ilyen nyelv például a Pascal, és a C.
• OOP támogató nyelv: alkalmazza mind az eljárás-orientált, mind az OOP elveket. Ilyen nyelv például a Delphi, C++.
• Tisztán OOP nyelv: nem alkalmazza az eljárás-orientált elveket, csak az OOP elveit. Ilyen nyelv például a Java, C#.

A támogató nyelvek használata nem szerencsés választás. Ugyanis mindkét elvek precíz ismeretét igénylik a programozótól. Ezen túl az elvek keveredése néha félreértelmezhető, nehezen érthető programkódot eredményez. Szerencsésebb választás a tisztán OOP elvek alkalmazásával történő programírás.

Az OOP elvek használata mellett az eljárás-orientált nyelvek minden lehetősége lefedhető. Ugyanakkor egy szintaktikailag jobban letisztult, erősebb lehetőségekkel rendelkező megvalósítást kapunk, mely használatával biztonságosabban, kevesebb hibalehetőség mellett programozhatunk.

Alapfogalmak

• Objektum-osztály: egy olyan egység, mely mezőket és metódusokat tartalmaz. A programozási nyelvekben az objektum-osztály gyakorlatilag egy típusként jelenik meg.
• Mező: az objektum-osztály része. Adattárolási feladatokat lát el, így sokban hasonló a szerepe a változókhoz. Ugyanakkor egy mező élettartama maga az objektum élettartamával jellemezhető. Tehát addig van a memóriában, amíg maga az objektum változó ezt igényli. Legjobban a hagyományos programozási nyelvek rekord (struktúra) fogalmában szereplő mezőre hasonlít. A különbség az, hogy ezen OOP fogalom egy objektum-osztály részeként szereplő mezőt jelöl.
• Metódus': az objektum-osztály részét képező valamely eljárás vagy függvény. Az különbözteti meg a hagyományos programozási nyelvek eljárás és függvény fogalmától, hogy ez valamely objektum-osztály részét képezi.
• Objektum: egy olyan változó, melynek a típusa valamely objektum-osztály.
• Inicializálás: Az objektum alaphelyzetbe állítása. Ebben a helyzetben a mezőknek valamilyen kezdőértékkel kell rendelkezniük.
• Felelősség: egy objektum felelős azért, hogy az inicializálás után máris megfelelő értékekkel rendelkezzenek a mezői, és később se kerülhessen olyan szituációba, amelynek során a mezőkbe hibás érték kerül.
• Adatrejtés: a mezők közvetlen hozzáférés (elsősorban írás) elleni védelme, melyet egy objektum azért alkalmaz, hogy ne kerülhessen valamely mezőjébe értelmetlen, s így végsősoron hibás érték.
• Konstruktor: egy speciális feladatú metódus, mely az inicializálás során a mezők kezdőértékének beállítását végzi (többek között). Egy objektum-osztálynak akár több konstruktora is lehet.
• Példányosítás: valamely objektum számára memóriafoglalás és inicializálás. Ennek során legalább egy konstruktor meghívása kötelező, hogy a mezők alaphelyzetbe állítása biztosan megtörténjen.
• Destruktor: egy speciális feladatú metódus, mely az objektum változó memóriából eltűnése előtt bizonyos nagytakarítás jellegű utasításokat hajt végre.

Példa

Az alábbi C# kódú példában egy egyszerű Objektum-osztályt mutat be. Figyeljük meg a részeket! Tartalmaz mezőket (vektor), konstruktort (TVektor), és metódusokat (elemekOsszege(), kiiras()):

class TVektor
{
  public int[] vektor = null;
 
  public TVektor(int kezdoMeret)
  {
     vektor = new int[kezdoMeret];
  }
 
  public int elemekOsszege()
  {
     int ret = 0;
     foreach (int x in vektor)
        ret += x;
     return ret;
  }
 
  public void feltoltVeletlenErtekkel(int also, int felso)
  {
     Random rnd = new Random();
     for (int i = 0; i < vektor.Length; i++)
        vektor[i] = rnd.Next(also, felso);
  }
 
  public void kiiras()
  {
     for (int i = 0; i < vektor.Length; i++)
       Console.Write(vektor[i]);
     Console.WriteLine();
  }
}

Valamint bemutatjuk hogyan kell egy ilyen objektum-osztályt példányosítani, és használni. Először mint típusnevet használjuk az objektum-osztály nevét, és deklarálunk egy ilyen típusú változót. Majd a new-al memóriát foglalunk, és alkalmazzuk ezen új memóriaterületre a konstruktort (TVektor(20)). Az elkészült objektum metódusait meg tudjuk hívni (t.kiiras()):

class FoProgram
{
  public static void Main()
  {
    TVektor t = new TVektor(20);
    t.feltoltVeletlenErtekkel(10,100);
    t.kiiras();
    int ossz = t.elemekOsszege();
    Console.WriteLine("Az elemek osszege={0}",ossz);
  }
}