Programozás I. Objektumorientált paradigma II. Osztályok és objektumok a memóriában Öröklés és többalakúság OOP alapelvek OOP modellezés

Programozás I. Osztályszintű tagok

Példányszintű tagok Objektumokhoz tartozó mezők és metódusok A példányszintű tagok az objektumpéldányok saját adatmezői, valamint saját adatain műveleteket végző metódusai Mátrix mátrix1 Elemek= ... (2D tömb) EgységmátrixE() Egyezik(másik mátrix) Szorzás(pont) Szorzás(vektor)

Osztályszintű tagok Osztályokhoz tartozó mezők és metódusok ProgI Osztályszintű tagok Osztályokhoz tartozó mezők és metódusok Az osztályszintű tagokkal (mezőkkel, metódusokkal) példányoktól független adattartalom és működés reprezentálható Mátrix mátrix1 Osztályszintű mező: Egyszer van tárolva, függetlenül az osztályból létrehozott objektumpéldányok számától Elemek= ... (2D tömb) EgységmátrixE() Egyezik(másik mátrix) ... (továbbiak) MaxSor=3 MaxOszlop=3 Vámossy (OE NIK)

Osztályszintű tagok Osztályszintű metódusok Mátrix mátrix1 Osztályszintű metódusok Akkor is elérhetők, ha az osztályból egyetlen objektum sem lett példányosítva Logikailag nem egy konkrét, már létező példányhoz kötődő feladatok végrehajtására alkalmasak Elemek= ... (2D tömb) EgységmátrixE() Egyezik(másik mátrix) ... (továbbiak) MaxSor=3 MaxOszlop=3 GenerálEgységmátrix() GenerálStringből(string) Egyezik(mátrixA, mátrixB)

C# Osztályszintű tagok A static kulcsszóval képezzük őket az osztálydeklaráción belül, és egy adott példány neve helyett a típus nevével hivatkozunk rájuk Osztályszintű tag lehet: adattag, metódus, tulajdonság, konstruktor (stb.), sőt maga az osztály is lehet statikus Az eddig ismert (nem static kulcsszóval deklarált) tagok "példányszintűek" voltak Számtalan példa az osztálykönyvtárban: Vagy pl. a főprogram (Main()) public static int kozosAdattag; //osztályszintű változó public static void PeldanytolFuggetlenFuggveny() { ... } //osztályszintű függvény Osztaly.kozosAdattag = 4; Osztaly.PeldanytolFuggetlenFuggveny(); i = int.Parse(s); //statikus metódus Console.WriteLine(s); //statikus metódus

Osztályszintű metódusok class Vektor { private double x; public double X { get { return x; } set { x = value; } } private double y; public double Y { get { return y; } set { y = value; } } public Vektor(double x, double y) this.x = x; this.y = y; } public static Vektor Parse(string str) int vesszo = str.IndexOf(','); int x = int.Parse(str.Substring(0, vesszo)); int y = int.Parse(str.Substring(vesszo+1)); return new Vektor(x,y); Console.WriteLine("Írj be egy vektort (x,y formában): "); string s = Console.ReadLine(); Vektor v = Vektor.Parse(s);

Osztályszintű metódusok Sok esetben ugyanazt a funkcionalitást statikus és nem statikus formában is meg tudjuk valósítani class Vektor { private double x; public double X { get { return x; } set { x = value; } } private double y; public double Y { get { return y; } set { y = value; } } ... public Vektor Osszead(Vektor b) return new Vektor(x + b.x, y + b.y); } public static Vektor Osszead(Vektor a, Vektor b) return new Vektor(a.x + b.x, a.y + b.y); Vektor v = new Vektor(1, 1); Vektor v2 = new Vektor(2, 3); Vektor sum = Vektor.Osszead(v, v2); Vektor sum2 = v.Osszead(v2); Console.WriteLine(sum.X + "," + sum.Y); Console.WriteLine(sum2.X + "," + sum2.Y); ÓE-NIK, 2013

Osztályszintű vagy példányszintű metódus? Legyen példányszintű, ha az adott példány állapotát módosítja Legyen osztályszintű, ha az adott példánytól független a működés, amit reprezentál Gyakran bizonytalan Ízlés és a fejlesztői közösség szokása dönthet, sokan a példányszintű metódusokat preferálják ilyenkor Egyéb szempontok: Ha bárhonnan, bármikor el kell tudni érni (kisebb, gyakran használt segédfüggvények), akkor sokszor statikus (pl. Math osztály függvényei) A statikus függvények kicsit gyorsabbak Szinte soha nem jelentős a teljesítmény, amit nyerünk így Bizonyos esetekben kötelező egy adott metódust statikusnak megírni Pl. főprogram, operátorok, kiegészítő metódusok stb. public void Szoroz(double s) { x = x * s; y = y * s; } - In computer programming, a utility class is a class that defines a set of methods that perform common, often re-used functions. - Örökléssel kapcsolatos szempontokat is mérlegelünk

Osztályszintű tagok - példa C# Osztályszintű tagok - példa using System; class Példányszámláló { private static int darabszám = 0; public static int Darabszám; get { return darabszám ; } } static Példányszámláló() darabszám = 0; public Példányszámláló() darabszám++; ~Példányszámláló() darabszám--; Console.WriteLine("Megszűnt egy példány. A fennmaradók száma: " + darabszám); Osztályszintű adatmező Osztályszintű konstruktor (fő célja az osztályszintű mezők kezdeti értékének beállítása) Konstruktor Destruktor

Osztályszintű tagok - példa C# Osztályszintű tagok - példa class PéldányszámlálóTeszt { static void Main() Példányszámláló teszt = new Példányszámláló(); Console.WriteLine("Létrehoztam egy példányt"); Console.WriteLine("Példányszám: " + Példányszámláló.Darabszám); for (int i = 0; i < 10; i++) new Példányszámláló(); Console.WriteLine("Létrehoztam még tíz példányt"); Console.ReadLine(); }

Ismétlés – példa: Téglalap osztály 1. class Téglalap { private int x; private int y; private int szélesség; private int magasság; public int X get { return x; } set { x = value; } } //... public Téglalap(int x, int y, int szélesség, int magasság) this.x = x; this.y = y; this.szélesség = szélesség; this.magasság = magasság;

Ismétlés – példa: Téglalap osztály 2. public bool Tartalmaz(int pontX, int pontY) { return this.X <= pontX && pontX < this.X + this.Szélesség && this.Y <= pontY && pontY < this.Y + this.Magasság; } public bool Tartalmaz(Téglalap másik) //... Fv túlterhelés Téglalap téglalap1 = new Téglalap(0, 0, 20, 40); Téglalap téglalap2 = new Téglalap(10, 10, 10, 10); Console.WriteLine(téglalap1.Tartalmaz(10, 10)); //true Console.WriteLine(téglalap2.Tartalmaz(téglalap1)); //false Console.WriteLine(téglalap1.Tartalmaz(téglalap2)); //true

Ismétlés – példa: Téglalap osztály 3. public static Téglalap Koordinátákból(int minX, int minY, int maxX, int maxY) { return new Téglalap(minX, minY, maxX - minX, maxY – minY); } public static Téglalap Metszés(Téglalap a, Téglalap b) int num = Math.Max(a.X, b.X); int num2 = Math.Min(a.X + a.Szélesség, b.X + b.Szélesség); int num3 = Math.Max(a.Y, b.Y); int num4 = Math.Min(a.Y + a.Magasság, b.Y + b.Magasság); return new Téglalap(num, num3, num2 - num, num4 - num3); Téglalap téglalap1 = new Téglalap(0, 0, 20, 40); Téglalap téglalap2 = new Téglalap(10, 10, 10, 10); Téglalap metszett = Téglalap.Metszés(téglalap1, téglalap2); //eredmény: 10, 10, 10, 10

Osztályok és (osztály típusú) változók a memóriában

Ezzel nem jön létre az objektum!!! C# Objektumreferencia Sok nyelvben az osztályok referenciatípusok (C# is): Az osztály típusának megfelelő változó egy referencia (mutató), amely az objektumra hivatkozik Több változó is hivatkozhat ugyanarra az objektumra Film film1; … film1 <= Film.Konstruktor(’Vasököl’, 16) Film film2; film2 <= film1; Kiír(film1 = film2) film2 <= Film.Konstruktor(Üvegtigris’, 18) Objektumhivatkozás Ezzel nem jön létre az objektum!!! Objektumlétrehozás ‚igaz’ Objektumlétrehozás ‚hamis’

Objektumhivatkozás, objektumok és osztály a memóriában ProgI 2006. tavasz - ©Vámossy C# Objektumhivatkozás, objektumok és osztály a memóriában film1 Objektumhivatkozás Osztály film2 Film Osztályhivatkozás Cím=‘Vasököl’ Korhatár=16 MindenAdat() Objektumok Osztályhivatkozás film1 <= Film.Konstruktor(…) film2 <= Film.Konstruktor(…) Cím=‘Üvegtigris’ Korhatár=18 film1.MindenAdat() OO Delphiben

„Rejtett” paraméter Működési elv: ProgI 2006. tavasz - ©Vámossy „Rejtett” paraméter A rejtett paraméter egy referencia, mely a megszólított objektum memóriacíme (Ha osztályszintű metódust hívunk, akkor az osztály címe) Minden metódusnak ez egy rejtett paramétere és típusa maga az osztály Egy futó metódus innen tudja, hogy éppen melyik példányon dolgozik Egymásból hívott metódusok esetén automatikusan továbbadódik Működési elv: Ha film1 Film típusú, akkor a film1.GetCim() üzenetet a fordító így értelmezi: Film.GetCim(film1) Megjegyzés: Ezt az utolsó paramétert a fordító automatikusan beépíti az összes metódusba, tehát nem nekünk kell!!! OO Delphiben

Példa: „egyke” minta (Singleton pattern) Alapötlet: osztály, ami max. egy példányban létezik. Megj.: más nyelven is kiépíthető, az adott nyelv eszközeivel class Singleton { private Singleton() { } private static Singleton _instance; static Singleton() _instance = new Singleton(); } public static Singleton GetInstance() return _instance; Singleton singleton1 = Singleton.GetInstance(); //... művelet... Singleton singleton2 = Singleton.GetInstance(); Console.WriteLine(singleton1 == singleton2); //true

Példa: „egyke” minta (Singleton pattern) Alapötlet: osztály, ami max. egy példányban létezik. Megj.: más nyelven is kiépíthető, az adott nyelv eszközeivel class Singleton { private Singleton() { } private static Singleton _instance; public static Singleton GetInstance() { //"lusta" inicializáció if (_instance == null) _instance = new Singleton(); } return _instance; Osztályszintű+példányszintű+láthatóság+referencia példa  Singleton singleton1 = Singleton.GetInstance(); //... művelet... Singleton singleton2 = Singleton.GetInstance(); Console.WriteLine(singleton1 == singleton2); //true

Öröklés és többalakúság (polimorfizmus)

Öröklődés A már meglévő osztálytípusok alapján készíthetünk új osztályokat – „örököltetés”, „leszármaztatás” Teljes hierarchiákat is létrehozhatunk Elnevezések: „ős(osztály)”, „utód(osztály)”, „leszármazott osztály”, „származtatott osztály” Utóbbi három megnevezés nem csak közvetlen utódokra vonatkozik A leszármazottak „öröklik” az őstípus tulajdonságait Meglévő osztályok újrafelhasználása, kiterjesztése, (módosítása – főként polimorfizmus által) Bővítheti, esetenként akár szűkítheti az őstípus állapotterét, illetve műveleteit Általában specializáció a cél The relationships of objects or classes through inheritance give rise to a hierarchy Régebben meglévő osztályok újrafelhasználása, módosítása, funkcionális kiterjesztése Az öröklés tranzitív :D, ha A osztály őse B osztálynak, és B osztály őse C osztálynak, akkor A osztály őse C osztálynak.

Öröklődés Általánosítás Specializálódás ProgI 2006. tavasz - ©Vámossy Öröklődés Általánosítás Specializálódás „is a” (angol. Magyarul: „az egy”) kapcsolat az utód és az ős közt „Egy rombusz az egy parallelogramma.” OO Delphiben

Öröklődés különféle nyelvekben ProgI 2006. tavasz - ©Vámossy Öröklődés különféle nyelvekben Az utód rendelkezik az őstípus tulajdonságaival De nyelvtől függő, hogy pontosan mit örököl C#: adatokat és a metódusok implementációit Egyszeres öröklésről akkor beszélünk, ha az adott nyelvben egy osztálynak csak egy őse lehet (vs. többszörös öröklés) Alaposztály: (egyszeres öröklésnél) a hierarchia legfelső osztálya OO Delphiben

Öröklődés példa Specializáció  generalizáció Ősosztály Utódosztályok ProgI 2006. tavasz - ©Vámossy Öröklődés példa Specializáció  generalizáció Bankszámla Egyenleg Befizet() Ősosztály Kifizet() Utal() Értékpapírszámla Folyószámla … értékpapírok … Kamat Utódosztályok … lekötés … … értékpapír vásárlása… … feltörés … … értékpapír eladása… OO Delphiben

Öröklődés példa Ősosztály Utódosztályok Személy Név Cím EMail Telefon ProgI 2006. tavasz - ©Vámossy Öröklődés példa Személy Név Cím EMail Ősosztály Telefon Dolgozó KapcsolattartóSzemély Beosztás Cég Utódosztályok BelépőkártyaSzám RegisztrálBelépés() RegisztrálKilépés() JelenlétEllenőrzés() OO Delphiben

Öröklődés Adatok öröklése ProgI 2006. tavasz - ©Vámossy Öröklődés Adatok öröklése Az utódosztály példányainak adatai = ősadatok + saját adatok. Metódusok öröklése Az utódosztály metódusaiban (illetve az utódosztály példányain, külső kódból) használható bármely ősbeli metódus Mind az adatok, mind a metódusok öröklése láthatóságtól is függő!!! OO Delphiben

Öröklődés Egy osztály örökítésekor két lehetőségünk van: ProgI 2006. tavasz - ©Vámossy Öröklődés Egy osztály örökítésekor két lehetőségünk van: Új mező felvétele (pl. BelépőKártyaSzám) Új metódusok felvétele (pl. RegisztálKilépés()) (És meglévő metódusok felülírása – főként polimorfizmus által) Megjegyzés. Új adatok megadása új metódusok nélkül általában értelmetlen, hiszen adatot csak metódussal szabad elérni (egységbezárás), és az ősmetódusok nyilvánvalóan nem ismerhetik az újonnan deklarált adatokat OO Delphiben

Öröklődés O1:Ős A, B O1.M1() O1. M2() Ős.M1() Ős.M2() O2. M1() ProgI 2006. tavasz - ©Vámossy Öröklődés Használható adatok Használható metódusok Mi hajtódik végre? Ős A B O1:Ős A, B O1.M1() O1. M2() Ős.M1() Ős.M2() M1() M2() Utód O2. M1() O2. M2() O2. M3() C D Ős.M1() Ős.M2() Utód.M3() O2:Utód A, B, C, D M3() OO Delphiben

Adatok és metódusok védelme 1. ProgI 2006. tavasz - ©Vámossy Adatok és metódusok védelme 1. Objektumpéldány védelme: private/protected public Osztály {Public:} Objektum: Osztály Objektum.Metódus Adat Metódus Osztály {Private/Protected:} Objektum: Osztály Objektum.Metódus Adat Metódus OO Delphiben

Adatok és metódusok védelme 2. ProgI 2006. tavasz - ©Vámossy Adatok és metódusok védelme 2. Osztály védelme örökítéskor: private public /protected Osztály Osztály {Public/Protected:} { Private:} Adat Adat Metódus() Metódus() ÚjOsztály ÚjOsztály Osztály.Adat Osztály.Adat Osztály.Metódus() Osztály.Metódus() OO Delphiben

Adatok és metódusok védelme 3. ProgI 2006. tavasz - ©Vámossy Adatok és metódusok védelme 3. Összefoglalás: Public: Minden metódus használhatja akár az osztályon belül, akár öröklésen keresztül, akár külső kódból. Protected: Az osztály saját metódusai férhetnek hozzá + hozzáférés öröklésen keresztül. Private: Az osztály privát deklarációja, csak az osztály saját metódusai férhetnek hozzá. OO Delphiben

Polimorfizmus (többalakúság) ProgI 2006. tavasz - ©Vámossy Polimorfizmus (többalakúság) Két teljesen különböző aspektus: Módszer polimorfizmus: Egy leszármazott osztály egy örökölt módszert újraimplementálhat, így ugyanolyan nevű metódus hívására a leszármazási fában szereplő különböző típusú objektumok különbözőképpen reagálhatnak Metódus felülírása lehetséges De mezőt nem lehet felülírni Objektum polimorfizmus: Minden egyes objektum szerepelhet minden olyan szituációban, ahol az ősosztály objektuma szerepelhet, nem csak a saját osztálya példányaként használható => A leszármazott osztály példánya mindig használható ős típusú változó helyén: Változó értékadásnál Paraméterátadásnál OO Delphiben

Polimorfizmus O1:Ős A, B O1.M1() O1. M2() Ős.M1() Ős.M2() O2. M1() ProgI 2006. tavasz - ©Vámossy Polimorfizmus Használható adatok Használható metódusok Mi hajtódik végre? Ős A B O1:Ős A, B O1.M1() O1. M2() Ős.M1() Ős.M2() M1() M2() Utód O2. M1() O2. M2() O2. M3() C D Utód.M1() Ős.M2() Utód.M3() O2:Utód A, B, C, D M1() M3() OO Delphiben

Polimorfizmus példa Ősosztály Utódosztályok ProgI 2006. tavasz - ©Vámossy Polimorfizmus példa Bankszámla Egyenleg Befizet() Kifizet() Ősosztály Értékpapírszámla Utal() … értékpapírok … … értékpapír vásárlása… Folyószámla Kamat … értékpapír eladása… … lekötés … Utódosztályok Utal() … feltörés … Kifizet() Utal() Őshöz képest más viselkedést definiálnak! Kifizet() Bankszámla számlám = new ÉrtékpapírSzámla(); //... használat... számlám.Utal(100000, "11773048-00005240-00000000"); OO Delphiben

Polimorfizmus Futásidejű kötés: ProgI Polimorfizmus Futásidejű kötés: Ha egy adott osztályhierarchiában (leszármazási fán) egy adott függvény különböző verziói létezhetnek, ÉS egy ős típusú változó elképzelhető, hogy valamilyen utód típusú példányt tartalmaz, Melyik „verziót” hívjuk meg az adott függvényből? Csak a futás során derül ki, hogy konkrétan melyikre van szükség. Közvetlenül a híváskor a hívó és a hívott függvény futás közbeni összerendelését nevezzük futásidejű kötésnek Megvalósítása nyelvenként különböző Az objektumnak kívülről csak egy meghatározott felülete látszódik, az implementációt nem láthatjuk, így ugyanolyan felületű objektumok is működhetnek másképpen, később számos előnye lesz ennek Vámossy (OE NIK)

Futásidejű kötés infrastruktúrája (C#) ProgI 2006. tavasz - ©Vámossy C# Futásidejű kötés infrastruktúrája (C#) értékpapírszámla1 Objektumhivatkozás Osztály folyószámla1 Folyószámla Osztályhivatkozás Befizet() Egyenleg=100000 Utal() Kamat=0.18 Kifizet() Osztályhivatkozás Értékpapírszámla Egyenleg=500 Befizet() Utal() Értékpapírok=… Kifizet() OO Delphiben

Futásidejű kötés infrastruktúrája (C#) ProgI 2006. tavasz - ©Vámossy C# Futásidejű kötés infrastruktúrája (C#) ?számla1 (Bankszámla típusú változóban pl Értékpapírszámla változó) Objektumhivatkozás Osztály Bankszámla Befizet() Utal() Osztályhivatkozás Kifizet() Egyenleg=500 Értékpapírszámla Értékpapírok=… Befizet() Utal() Kifizet() OO Delphiben

Példa: többalakúság egyszerű alkalmazása static void EmailtKüld(Személy címzett, string üzenet) { string ideküldöm = címzett.EMail; //... } //... Dolgozó főnök; //... használat... EmailtKüld(főnök, „…"); Munkahelyi nyilvántartó rendszerünkben küldhetünk e-mailt egy tetszőleges személynek. Nem kell megszabni, hogy a címzett Dolgozó vagy Kapcsolattartó legyen. (Mindkettőnek van e-mail-címe – Személyből öröklik)

Példa: többalakúság egyszerű alkalmazása Bankszámla[] bankszámlák; //... bankszámlák[1] = new ÉrtékpapírSzámla(); bankszámlák[6] = new Folyószámla(); Banki nyilvántartó rendszerünkben egy embernek több bankszámlája is lehet. Nem szükséges fajtánként külön tárolni, közös tömbben is elhelyezhetjük őket.

Többalakúság összetettebb alkalmazása ProgI 2006. tavasz - ©Vámossy Többalakúság összetettebb alkalmazása Megszüntet() függvény implementációja: … Ha van a banknak tartozás… Utal(tartozásÖsszege, bankSzámlaszáma); … Ha van az adóhatóságnak tartozás… Utal(tartozásÖsszege2, navSzámlaszáma); Kifizet(maradék) Bankszámla Egyenleg Utal(tartozásÖsszege, bankSzámlaszáma); Befizet() Kifizet() Utal(tartozásÖsszege2, navSzámlaszáma); Utal() Kifizet(maradék) Megszüntet() Értékpapírszámla Folyószámla … új mezők … új mezők ÉrtékpapírSzámla értékpapírSzámla; Folyószámla folyószámla; //... értékpapírSzámla.Megszüntet(); folyószámla.Megszüntet(); … új metódusok … új metódusok Kifizet() Kifizet() Utal() Utal() OO Delphiben

Példa: „stratégia” minta (Strategy pattern) Alapötlet: algoritmusok egy családját reprezentáljuk osztályok formájában. A felhasználó osztályban felcserélhetők. RendezésiStratégia (ős) TermékLista Rendez(objektumok) objektumok Rendez(rendezésiStratégia) BuborékRendezés (utód) GyorsRendezés (utód) Rendez(objektumok) Rendez(objektumok) public void Rendez(RendezésiStratégia rendezesiStrategia) { rendezesiStrategia.Rendez(objektumok); } TermékLista lista = new TermékLista(); //... használat... lista.Rendez(new BuborékRendezés());

OOP alapelvek

ProgI 1. alapelv: absztrakció Meghatározzuk a szoftverrendszer absztrakt elemeit Meghatározzuk az elemek állapotterét Adatelemek Meghatározzuk az elemek viselkedésmódját Funkciók végrehajtása Állapotváltoztatások Meghatározzuk az elemek közötti kapcsolattartás felületeit és protokollját Az osztály mindig az adott feladatban fontos tulajdonságokat/képességeket tartalmazza. Oka: egyszerűsítés Eszközrendszere: class definíció Vámossy (OE NIK)

2. alapelv: egységbezárás ProgI 2. alapelv: egységbezárás Az objektumok adatait és a rajtuk végezhető műveleteket szoros egységbe zárjuk Pontosan definiáljuk az adatok eléréséhez/használatához szükséges műveleteket Elvileg az adatok csak ezek segítségével érhetők el, és más műveletek az objektummal nem végezhetők Meghatározott feladatot ellátó, „öntartalmazó” egységként kezeljük őket Oka: Átláthatóság Újrafelhasználhatóság Adatok fizikailag közel vannak a rajtuk dolgozó műveletekhez, ami a módosíthatóságot segíti Eszközrendszere: class definícióban adatok+műveletek Vámossy (OE NIK)

3. alapelv – adatrejtés Pontosan meghatározzuk az osztály kifelé való „kapcsolódási pontjait” Az objektumokon belül elkülönítjük a belső (privát) és a külső (nyilvános) adatokat és műveleteket A belső használatú műveletek privátok A nyilvános adatok és műveletek a szoftverrendszer többi objektuma számára (is) elérhetők Tájékozódás az objektum állapotáról Az objektum állapotának módosítása Oka: Pontos megvalósítás, pontos adatábrázolás elrejtése Az objektum rejtett része meghatározza a szabadon módosítható részeket Az adatelérés kontrollálása véd a hibáktól Eszközrendszere: láthatóságok, tulajdonságok getter/setter metódusai (még publikus esetben is) Egységbezárás+adatrejtés szokott egyben lenni (és a kódújrafelhasználás az, ami nem szerepel) Adatrejtés az egységbezásás biztonsági eszközrendszere. Nélküle nem létezik (biztonságos módon) az egységbezárás. Adatok a műveletekkel úgy kerülhetnek BIZTOSAN egy egységbe, ha megtilthatjuk, hogy kívülről valaki hozzányúljon és bármilyen műveletet végezzen vele. http://www.algosome.com/articles/java-access-modifier-uses.html

4. alapelv: öröklés A már meglévő osztálytípusok alapján készíthetünk új típusokat, melyek rendelkeznek az őstípus tulajdonságaival Ez egy specializációs művelet („származtatás”) A leszármazottak öröklik az őstípus tulajdonságait A leszármazottak bővíthetik, esetenként akár szűkíthetik az őstípus állapotterét, illetve műveleteit Teljes leszármazási hierarchiákat is létrehozhatunk Oka: Kódújrafelhasználás (osztályok közötti logikai kapcsolat fizikai megjelenítése) Eszközrendszere (polimorfizmussal együtt): ősosztály megadása, virtuális/absztrakt metódusok, absztrakt osztályok, interfészek megvalósítása/kiterjesztése (a prog II-n fogják tárgyalni) improve code readability and enable the reuse of functionality.

5. alapelv: többalakúság/polimorfizmus ProgI 5. alapelv: többalakúság/polimorfizmus A különböző, egymásból származó objektumtípusok azonos megnevezésű műveletei a konkrét objektumtól függően más- más konkrét megvalósítással rendelkezhetnek Ugyanazt a műveletet eltérő módon végezheti az őstípus és a leszármazott Az alapelv lehetőséget teremt rá, hogy azonos névvel hivatkozzunk az azonos célú, de a leszármazási hierarchia különböző szintjein más-más megvalósítást kívánó műveletekre Az egyes őstípusok leszármazottai mindenre alkalmasak, amire az adott őstípus alkalmas volt Minden olyan helyzetben és funkcióban, ahol az őstípus szerepelhet, annak bármely leszármazottja is szerepelhet Oka: Módszerpolimorfizmus: kódújrafelhasználás különféle formái (bővítés lehetősége egy már létező funkcionalitás megtartása mellett – lásd „többalakúság összetettebb alkalmazása” példánkat) Objektumpolimorfizmus: módosításokkal szembeni rugalmasság, szabad bővítés újabb objektumfajtákkal… stb. Vámossy (OE NIK)

6. alapelv: kódújrafelhasználás ProgI 6. alapelv: kódújrafelhasználás A korábban említett alapelvek mentén valósul meg Absztrakció, egységbezárás, adatrejtés segítségével Konkrét feladatot ellátó, jól tervezett, biztonságosan használható osztály átvihető más programba Akár bináris formában (könyvtárak (libraryk), komponensgyűjtemények) Örökléssel Adatokat és műveleteket nem kell újra megírni Polimorfizmussal Meglévő implementáció kiegészítését végezhetjük el úgy, hogy a régi implementáció nem módosul Felülírt függvények segítségével („többalakúság összetettebb alkalmazása” példánkban) Vagy eleve általánosra megírt függvények elfogadnak újabb létrehozott osztályokat is („többalakúság egyszerűbb alkalmazása” példáinkban) Vámossy (OE NIK)

OOP modellezés

Bevezető fogalmak Absztrakció lat. 1. elvonatkoztatás, elvonás; a leglényegesebb tulajdonságok kiemelése és általánosítása; 2. elvont fogalom [Idegen szavak és kifejezések szótára, Akadémiai Kiadó] Az OO paradigma

Prog1_OOP_modell 2006. tavasz - ©Vámossy Programkészítés Absztrakciós folyamat, amelyben a valós világban létező jelenséget (megoldandó problémát) valamilyen programozási eszköz absztrakciós szintjén képzünk le A munka nehézsége függ a leképezendő jelenség/folyamat bonyolultságától (komplexitásától) a valóság és a programozási eszköz absztrakciós szintjének különbözőségétől OO Delphiben

Prog1_OOP_modell Programozási nyelvek A programozási eszközök absztrakciós szintjei különbözőek: Assembly: adott számítógép-architektúra utasításkészletének leképezése Strukturált/procedurális programnyelvek: adatszerkezetek és algoritmusok absztrakciós szintje a valós világ fogalmaihoz nem közeli Objektumorientált nyelvek: együttműködő objektumok absztrakciós szintje A valóságban is léteznek Vámossy (OE NIK)

Programozás mint modellkészítés Program: a valós világ egy szeletének működő modellje Ebben a szemléletben a valós világ absztrakt modelljét (analízis modell) kell leképezni a programozási eszközre OOP szemlélet szerint az analízis modell elkészítése során a valóságot objektumok halmazaként tekintjük. Ezen objektumok egymással kapcsolatban vannak és együttműködnek Az OO paradigma

Objektumtól objektumig Prog1_OOP_modell 2006. tavasz - ©Vámossy Objektumtól objektumig A valós világ eleme Absztrakció Nyelvi elem Valós objektumok Absztrakt adattípus Osztály Objektum1 Megvalósítása programozási eszközzel (implementáció) Objektum3 Objektum2 Absztrakció és/vagy formális leírás Példányosítás 1. szint 2. szint 3. szint OO Delphiben

Objektumtól objektumig 1. szint Prog1_OOP_modell Objektumtól objektumig 1. szint Tanulmányozzuk a valós objektumokat, és megkeressük azoknak a probléma megoldása szempontjából fontos adatait és viselkedésmintáit. (Az absztrakció fogalmából: „A leglényegesebb tulajdonságok kiemelése”) Megkeressük azon objektumcsoportokat, amelyek azonos adatokkal és viselkedésmintákkal rendelkeznek, és elnevezzük ezeket a csoportokat. (Az absztrakció fogalmából: „általánosítás”) Oktató vércukorszintje Neptun szempontjából lényegtelen, de lényeges, hogy melyik intézetben dolgozik Létre jön Neptun szempontjából az oktató fogalom Vámossy (OE NIK)

Objektumtól objektumig Prog1_OOP_modell 2006. tavasz - ©Vámossy Objektumtól objektumig A valós világ eleme Absztrakció Nyelvi elem Valós objektumok Absztrakt adattípus Osztály Objektum1 Megvalósítása programozási eszközzel (implementáció) Objektum3 Objektum2 Absztrakció és/vagy formális leírás Példányosítás 1. szint 2. szint 3. szint OO Delphiben

Objektumtól objektumig 2. szint Prog1_OOP_modell Objektumtól objektumig 2. szint Az előzőleg definiált fogalom leképzése a programozási eszközre (osztálydefiníció). Ez egy minta a program működéséhez szükséges objektumok létrehozására Neptun szempontjából lényeges adatok (név, intézet, neptunkód) Viselkedési forma: Kurzust hirdet, vizsgaidőpontot ír ki, jegyet ír be, nem nézheti meg a hallgató adatait Vámossy (OE NIK)

Objektumtól objektumig Prog1_OOP_modell 2006. tavasz - ©Vámossy Objektumtól objektumig A valós világ eleme Absztrakció Nyelvi elem Valós objektumok Absztrakt adattípus Osztály Objektum1 Megvalósítása programozási eszközzel (implementáció) Objektum3 Objektum2 Absztrakció és/vagy formális leírás Példányosítás 1. szint 2. szint 3. szint OO Delphiben

Objektumtól objektumig 3. szint Prog1_OOP_modell Objektumtól objektumig 3. szint Akkor és annyi objektumot kell létrehozni a program futása során, amelyek együttműködve képesek a valóságot modellezni. Oktató be akarja írni adat hallgató vizsgajegyét a Neptunba: Létrejön egy oktató objektum a megfelelő adatokkal, egy vizsgaalkalom típusú objektum a megfelelő adatokkal, és egy hallgató típusú objektum a hallgató adataival Az oktató objektum üzen a vizsgaalkalom objektumnak, megadva a hallgató nevét és jegyét, aki (ellenőrzések után) egy üzenetet küld a hallgató objektumnak, megváltoztatva ezzel az állapotát. Vámossy (OE NIK)

OOP programkészítés „algoritmus” 1. Problémaanalízis Reprezentálandó információ (információtípus! Nem konkrét információdarab) és ahhoz kapcsolódó műveletek, illetve akár elvégzendő feladatok azonosítása a specifikációból Hierarchiáik azonosítása (öröklési célból) Kimenet: az információt és/vagy akár az elvégzendő feladatokat reprezentáló osztályok nevei és rövid leírásuk Osztályok tervezése A műveletek reprezentálásához: Műveletek formájában fejezzük ki az osztályok összes tevékenységét Az adat reprezentálásához: Primitív típust választunk, ha azzal az adat maradéktalanul reprezentálható. Többnyire új osztályt készítünk, ha egy reprezentálandó információ több „információdarabot” foglal magába. Adott osztály tartalmazhat/használhat példányt egy másik osztályból, ha az osztályban reprezentálandó információ egy része a másik osztály példányával kifejezhető (Megj: adott osztály használhat példányt akár ugyanabból az osztályból is.) Terv kipróbálása példákkal

OOP programkészítés „algoritmus” 2. Implementáció Létrehozunk megfelelő példányokat (objektumokat) a megfelelő időben, és megoldjuk a kommunikációjukat Adott feladathoz szükségünk lehet az eredeti probléma objektumain túl technikai szerepű osztályokra/objektumokra is

Objektumkapcsolatok – Asszociáció „Adott osztály tartalmazhat/használhat egy példányt egy másik osztályból” Asszociációnak nevezzük, ha két osztály (objektumai) tetszőleges kapcsolatban vannak egymással. „A bankban számlák nyithatók” „A tanár a szerzője a könyvnek” „A diák fel tud iratkozni a kurzusra” „A megrendelés adatai az adatbáziskapcsolaton keresztül mentődnek” „A neptunban létrehozhatók vizsgaalkalmak” Rengeteg formában megjelenhet, de két fontos speciális esete van: kompozíció, aggregáció

Objektumkapcsolatok – Kompozíció Speciális asszociáció: „has a” kapcsolat (angol. Magyarul: „van egy”) „A bankszámlában tárolva vannak a forgalmi adatok” class Tranzakció { DateTime dátum; int összeg; //... } class Bankszámla Tranzakció[] tranzakciók;

Kompozíció Kvíz KvízKérdés kérdés KérdésSzöveg=‚ ... ’ LehetségesVálaszDb=1 Kvíz k VálaszLehetőségek={ ... } Kérdések = { ... } HelyesVálaszok={ ... } Értékel() KiválasztottVálaszok={ ... } Választ(VálaszLehetőség) VálaszLehetőség v1 VálaszSzöveg=‚ ... ’ CsatoltKép= ...

Kompozíció Játékpálya/labirintus Akadály akadály1 PozícióX=0 Labirintus l PozícióY=8 Szörnyek={ ... } Akadályok= { ... } Szörny szörny1 PozícióX=0 PozícióY=9 Életerő=100 Mozog()

Objektumkapcsolatok – Aggregáció Speciális asszociáció: „has a” kapcsolat (angol. Magyarul: „van egy”) A kompozíciótól abban különbözik, hogy a tartalmazott példány(ok) élettartama nem kötődik a tartalmazóéhoz „A bankszámlának van egy tulajdonosa” class Bankszámla { Személy tulajdonos; //... }

Aggregáció Adatbázis-kapcsolat DBParancs parancs1 Kapcsolat=k DBKapcsolat k ParancsSzöveg=’select ...’ Szerver=’...’ ParancsMaxIdőMs=200 Port=’...’ Végrehajt() Felhasználó=’...’ Jelszó=’...’ DBParancs parancs2 Kapcsolódik() Kapcsolat=k KapcsolatBontása() ParancsSzöveg=’update ...’ ParancsotGenerál() ParancsMaxIdőMs=∞ Végrehajt()

Névterek

Névterek 1. Az OO paradigma jellemzője az elnevezések óriási száma ProgI Névterek 1. Az OO paradigma jellemzője az elnevezések óriási száma Minden osztálynak, objektumnak, mezőnek, metódusnak egyedi nevet kell adni, hogy a későbbiekben hivatkozni lehessen rájuk Nem könnyű jól megjegyezhető, a célt később is felidéző neveket adni A programok méretével egyenes arányban nő a névütközések valószínűsége A programok általában nem csak saját osztályokat használnak fel Névütközést nem tudnánk elkerülni, pl. több helyről veszünk osztályokat, és mindkét komponens csomagban van “Jogosultság” osztály Vámossy (OE NIK)

ProgI Névterek 2. A névtér, mint az elnevezések érvényességének tartománya, hierarchikus logikai csoportokra bontja az elnevezéseket Minden elnevezésre csak a saját névterén belül lehet hivatkozni – külön jelzés nélkül Ennek megfelelően a saját névterén belül minden elnevezés egyedi A névterek általában tetszőleges mélységben egymásba ágyazhatók Azonos elnevezések más-más névtereken belül szabadon használhatók, így erősen lecsökken a névütközési probléma jelentősége Névütközést nem tudnánk elkerülni, pl. több helyről veszünk osztályokat, és mindkét komponens csomagban van “Jogosultság” osztály Vámossy (OE NIK)

ProgI Névterek - példa Névütközést nem tudnánk elkerülni, pl. több helyről veszünk osztályokat, és mindkét komponens csomagban van “Jogosultság” osztály Vámossy (OE NIK)

C# Névterek A névterek az elnevezések tetszőleges logikai csoportosítását teszik lehetővé Nincs közük a fizikai tároláshoz (fájlokhoz és mappákhoz) Egy fájlban több névtér, egy névtér több fájlban is elhelyezhető Tetszőlegesen egymásba ágyazhatók A beágyazott névterek tagjait a „ . ” karakterrel választhatjuk el A névtérbe be nem sorolt elemek egy ún. globális névtérbe kerülnek namespace A.B { class Másik {…} } namespace C class Harmadik {…} … A.B.Másik példa2 = new A.B.Másik(); C.Harmadik példa3 = new C.Harmadik(); namespace A { namespace B class Egyik {…} } … A.B.Egyik példa = new A.B.Egyik(); A két kódban definiált A.B névtér azonos (Az Egyik és Másik osztály ugyanazon névtérben van) A névterek nevének Microsoft által javasolt formátuma: <Company>.(<Product>|<Technology>)[.<Feature>][.<Subnamespace>]

Névterek C# Minden névre a saját névterével együtt kell hivatkozni Ez az ún. teljesen minősített név (fully qualified name), formája: névtér.alnévtér.alnévtér(...).elnevezés A névterek hivatkozás céljára előkészíthetők a using kulcsszó segítségével Ezt követően az adott névtérben található elnevezések elé hivatkozáskor nem kell kiírni a névteret, feltéve, hogy az elnevezés így is egyértelműen azonosítható A névtereknek álnév is adható Célja a hosszú névterek egyértelmű rövidítése System.Console.WriteLine(); System.Threading.Thread.Sleep(100); pi = System.Math.PI; using System; using System.Text; using System; using SOAP = System.Runtime.Serialization.Formatters.Soap; ... SOAP.SoapFormatter formazo = new SOAP.SoapFormatter(); Console.WriteLine(formazo);