Programozási paradigmák és technikák. Előadás: Hajnal Éva Gyakorlat: Burián Ágnes

Programozási paradigmák és technikák Előadás: Hajnal Éva Gyakorlat: Burián Ágnes

Paradigma Egy tudományterület általánosan elfogadott nézetei (fogalmai, szakkifejezései) egy adott korszakban, időpontban. Egy szó összes ragozott alakjának rendszerezett leírása. (például igeragozási tábla)(lásd: Magyar Értelmező Kéziszótár) Egy mondat szakasz helyettesítésére alkalmas kifejezések osztálya, gyűjteménye (nem azonos értelmű, jelentésű (szinonímák), hanem azonos módon használható szavak). A paradigma a gondolkodásoknak, vélekedéseknek, értékeknek és módszereknek egy adott társadalom vagy szűkebben egy tudományos közösség minden tagja által elfogadott összegzését jelenti. 2

Adatbázisok Programnyelvek C#, Java, Assembly Adatszerkezetek Hogyan kell programot írni Algoritmusok Programozási paradigmák és technikák UML Alapismeretek Szoftver ismeretek Hogyan kell tervezni Informatikus tudása Hogyan kell dokumentálni Rendszertervezés Gazdasági ismeretek Hardver ismeretek 3

Tematika 1 Rekurzió: Fibonacci (rekurzív és nem rekurzív), QuickSort (rekurzív és nem 2012.02.13- rekurzív) 2 OO programozás C# nyelven 2012.02.20 Osztályok, objektumok. Konstruktor, destruktor, this. Beágyazott osztályok. Egyszerű típuskonverziók Mezők, metódusok. Átdefiniálás (overloading) Névterek. Láthatóság. Felbontott típusok (partial types) 3 Öröklés 2012.02.27 Többszörös öröklés lehetőségei a különböző nyelvekben. Konstruktorok az öröklésben. Hívási, végrehajtási sorrend. Paraméterezett őskonstruktor hívása. Különböző konstansok és inicializálásuk Metódusok elrejtése. Az ősosztály azonos nevű metódusának hívása. Öröklés és értékadás. Explicit típuskonverzió. Az Object.GetType(). Az is, as operátorok.. 4 Polimorfizmus 2012.03.05 Nem virtuális metódusok, elrejtés. Virtuális metódusok, felüldefiniálás. Futásidejű kötés, polimorfizmus. Virtuális Metódus Tábla. Konstruktorok, destruktorok feladata. Virtual, override, new, new virtual. Virtuális metódus elrejtése. A virtualitás újrakezdése. Statikus és virtuális metódusok. Lezárt metódus, lezárt osztály Delegált függvények 5 Absztrakt osztály és interfész. Absztrakt metódus. Absztrakt osztály 2012.03.12 Generikus osztályok Interfész. Metódusok implementációja. Láthatóság interfész esetén. Explicit implementált interfész. Absztrakt osztály vagy interfész. 6 Iterátorok. Kivételkezelés. Kivétel dobása, elkapása. Kezeletlen kivétel. Kivételek 2012.03.19 egymásba ágyazása. Az osztálykönyvtár és a kivételkezelés. Operátor overloading. Operátor. Átdefiniálható operátorok. Precedencia. Implicit, explicit Programozási paradigmák konverzió. és technikák 4

7 2012.03.26 Dinamikus memóriakezelés. Verem/sor. Statikus megvalósítás, dinamikus megvalósítás. 8 2012.04.02 ZH Gráfok, Gráfalgoritmusok 9 Szünet 10 2012.04.16 11 2012.04.23 12 2012.04.30 Láncolt listák létrehozása Láncolt listák bejárása. Keresés, beszúrás, törlés, hulladékgyűjtés. Fejelt listák. Kétirányú listák Fa adatszerkezetek. Fát reprezentáló adatstruktúrák. Adatmodell, eljárásmodell. Adatszerkezetek rendszerezése. Absztrakt társzerkezetek. Vektor, lista. Bináris fák. Megvalósításuk a memóriában. Bináris fák bejárása, keresés. Beszúrás, törlés. BST fák, AVL fák. Általánosított fák, piros-fekete fa, B-fa Rendezések. A rendező algoritmusok bonyolultsága. Radix rendezés. Kupacrendezés (HeapSort). Kupacrendezés bonyolultsága. Útvonalak hosszúsága, a Huffman algoritmus. 13 2012.05.07 A tábla, mint adatszerkezet. Hasítás. Hasító függvények. Az összeütközések feloldása. Hasítás és keresőfák. Hasítás alkalmazásai 5

Követelmények Az aláírás megszerzésének feltétele: A két gépes ZH, és az elméleti ZH megírása, a házi feladat beadása. A ZH-k és házifeladatból megszerezhető pontok 50%-nak teljesítése, vagyis a megszerezhető 120 pontból minimum 60 pontot kell elérni. A vizsga jegy: A gyakorlatokon a 2., 3., 4., 5., 8., 10., 11., 12. héten egy-egy 5 pontos, a 6., 13. héten egy-egy 20 pontos gépes ZH megírása, a 13. héten 20 pontos önálló feladat beadása és ebből beszámoló. Az előadás anyagából a 8. héten egy 20 pontos elméleti ZH lesz. Összesen elérhető 120 pont. A vizsgán további 120 pont érhető el. A hozott pontszám a vizsga pontszámához hozzáadódik. Osztályozás: 193-240 jeles 169-192 jó 145-168 közepes 121-144 elégséges 6

Teszt (igaz-hamis) 1. Szintaktika a szabályok összesége, amely megszabja a forráskód felépítését. 2. A C# programnyelv nem különbözteti meg a kis- és a nagy betűket: Consol.WriteLine ugyanaz mint consol.writeline 3. Az if egy kulcsszó, azaz a forráskódban a saját meghatározott jelentésén kívül nem lehet másra használni. 4. //Ezt a programsort a C# fordítója nem fordítja le. 5. A C# erősen típusos nyelv, ami azt jelenti, hogy minden egyes változó típusának már fordítási időben ismertnek kell lennie. 6. Az int és a System.Int16 ugyanazt jelenti, egymással helyettesíthetők. 7. Egy változó abban a blokkban használható, amelyben definiálva lett. 8. if(a<n && a%2==0) és if(a<n & a%2==0) teljesen ugyanúgy hajtódik végre. 7

Teszt (igaz-hamis) 9. Az alábbi értékadás helyes: 10=++a; 10. Teljesen mindegy, hogy a programban mit írok: a++ vagy ++a, ugyanaz történik 11. int x=10; int y=3; int z=x/y; esetén z értéke 3,333 12. for (int i=0;i<10;i++){k } k utasítás 10-szer lesz végrehajtva 8

Programozási paradigmák Oszd meg és uralkodj paradigma A nagyobb feladat kisebb egymástól független részfeladatokra bontása Dinamikus programozás paradigma Ha a feladat nem bontható fel egymástól független részfeladatokra Az egymástól függő részfeladatok behatárolása, és a részeredmények tárolása 9

Függvények A függvény utasítások logikailag összefüggő csoportja, mely önálló névvel és visszatérési értékkel rendelkezik. Hívása printf( Hello ); Console.Clear(); Consol.WriteLine( Hello ); a=sin(x); Consol.WriteLine(sin(x)); Szerkezete Visszatérésiértéktípusa FüggvényNeve(paraméterlista) { Utasítások; Return visszatérési érték; } 10

Függvény végrehajtása, és definíciója static void terulet() { Console.WriteLine("Kérem a négyzet oldalát:"); int t = Int32.Parse(Console.ReadLine()); Console.WriteLine( t * t); } 1. Program belépési pontja (Entry point) static void Main(string[] args) { terulet(); Console.ReadLine(); } 11

Eljárás végrehajtása I. 12

Eljárás végrehajtása II. 13

Változók hatásköre A változók hatásköre az őket tartalmazó blokkra terjed ki. Ha több eljárás közt osztunk meg egy változót: Static módosítóval rendelkező eljáráshoz static módosítójú változót kell definiálni. 14

Függvény visszaadott értéke void int double Összetett adat pl. tömb Eljárás függvény 15

Paraméter átadás static void Kiiras(int a,int b) { Console.WriteLine("A {0}+{1}={2}",a,b,a+b); } 16

Függvény paraméterei Bemenő-Kimenő paraméterek Érték szerinti cím szerinti paraméter átadás Paraméterek, helyi változók tárolása 17

Átadott paraméter egyeztetése 18

Érték szerinti paraméter átadás 19

Cím szerinti paraméter átadás Átmenő, kimenő paraméter Ref, out 20

Paraméterátadás Szignatúra: függvény neve, és paraméterlistája az abban levő típusokkal Írhatunk azonos nevű függvényeket, ha a szignatúrájuk különböző. Polimorfizmus. Kérdés: Lehet-e egy programon belül definiálni az alábbi függvényeket? void mozgat(int x, int y); void mozgat (int x); void mozgat (int y); 21

File kezelés C#-an többszintű file kezelés létezik egymás mellett. Form alapú filekezelés (OpenFileDialog, SaveFileDialog) File-ok streamek, adatfolyamok Bináris file kezelés byte-ról byte-ra olvasható, írható a file XML fileok használata, szerializáció Konfigurációs file-ok használata 22

File kezelés Magas szintű file kezelés: a fileokat adatfolyamnak stream-nek tekintjük akárcsak a Console I/O-t. A stream a definíciója és a megnyitása után írható, olvasható. Használat végén be kell zárni!!!! System.IO névtér használata 23

//névtér megadása Using System.IO; File stream példa //FileStream megadása FileStream fs=new FileStream( c:\\eva\\text.txt, FileMode.Open); //Stream megadása olvasáshoz, íráshoz StreamWriter StreamReader rs=new StreamReader(fs); String s=rs.readline(); While(s!=null) { Console.WriteLine(s); s=rs.readline(); } rs.close(); fs.close(); 24

FileMode értékei Create CreateNew Open OpenOrCreate Append Truncate LÉTREHOZ (ha van törli) LÉTREHOZ (ha van akkor hiba) Megnyit (ha nincs akkor hiba) Megnyit, ha nincs létrehozza Megnyit hozzáfűzésre Megnyit és töröl 25

FileAccess értékei Read Write ReadWrite 26

A file vizsgálata Létezik-e File.Exists() Elértük-e a végét : a beolvasott sor értéke null 27

File-ba írás Using System.IO; StreamWriter sw=new StreamWriter(@ c:\teszt.txt,filemode.open, FileAccess.Write, FileShare.None); For (int i=0; i<10;++i) { } sw.write(i.tostring()); sw.write( \n ); Sw.Close(); 28

Teszt Static int szamol(int a, double b) {return b/a;} 1. A szamol() egy eljárás 2. Az a és b formális paraméterek 3. Console.WriteLine( {0},szamol(5,6)); programsor helyes 4. Az int c=szamol(2,5) eredménye 2.5 5. Cím szerinti paraméterátadás van a 4. feladatban 6. A Main függvénynek is lehet paramétere 7. Lehet készíteni static int szamol( int a, int b) fejlécű függvényt is ugyanebben a programban 8. A függvény szignatúrája a neve és paramétereinek típusa 29

Rekurzió fogalma A rekurzió a ciklusnál bonyolultabb programszerkezet, de ugyanarra való egy tevékenység ismételt végrehajtására. Rekurzió: Egy függvény saját magát hívja meg (közvetve, vagy közvetlenül). 30

Definíció (Specifikáció) 1. feladat: Számítsuk ki N faktoriálist Iteratív definíció Rekurzív definíció n! n i 1 i n 0 1 n 0 n! n *( n 1 1)! ha ha n 0 n 0 31

Rekurzió fogalma 1. feladat: Számítsuk ki N faktoriálist static int faktor(int n) { if (n == 0) return 1; int f=1; for (int i = 1; i <= n; i++) { f = f * i; } return f; } static int frek(int k) { if (k > 0) return k*frek(k-1); return 1; } 32

Kérdések 1. Hogy kerül ugyanazzal a kóddal megvalósított eljáráshoz mindig más bemenő érték? Bemenő érték problémája 2. Hogy kerül a hívó eljárásban a függvényérték felszínre? Értékvisszaadás problémája 3. Lokális a k változó. Melyik a sok közül? A lokális változók problémája 33

Rekurzív algoritmus készítése Közvetlen rekurzió: Ha az A algoritmus egyik lépése az A algoritmus végrehajtását írja elő. Közvetett rekurzió: Ha az A algoritmus egyik lépése a B algoritmus végrehajtása, a B algoritmus előírja az A algoritmus végrehajtását. Rekurzív algoritmusok végességének kritériumai Az algoritmusnak tartalmaznia kell egy alapesetet, amely közvetlenül megvalósítható Minden hivatkozásnál közelebb kell kerülni ehhez az alapesethez 34

Rekurzió alkalmazása a feladatmegoldásban Rekurzív specifikáció Nemrekurzív specifikáció Rekurzív algoritmus Nemrekurzív algoritmus Rekurzív programnyelv Nemrekurzív programnyelv Számítógép 35

2. Feladat A Fibonacci-számok Nyúlpár szaporodását írja le 0,1,1,2,3,5,8,13,21,34,55 Def: 0 ha n 0 Fib( n) 1 ha n 1 Fib( n 1) Fib( n 2) ha n 1 36

Faktoriális számítás sebességének vizsgálata N Iteratív Rekurzív 10 0,04 0,2 20 0,08 0,42 50 0,2 1,05 70 0,28 1,5 37

Rekurzió Iteráció Fibonacci sor, faktoriális számítás, Pascalháromszög 1. Rekurzió helyettesíthető iterációval 2. Az f(n-1), f(n-2) értékek tárolhatók tömbben Fib(N) F[0]=0, F[1]=1 Ciklus I=2 től N-ig F[I]=F[I-1]+F[I-2] Ciklus vége Fib=F[N] Eljárás vége 38

Jobbrekurzió Példa: Egy szöveg betűinek kiírása Betűk(X) Ha X nem üres akkor Ki: Első(X) Betűk(Elsőutániak(X)) Eljárás vége A rekurzív hívás a függvény végén van, utána már nincs szükség a függvény lokális változóira. A paraméterek az eredményt tartalmazzák, vagy a rekurzió szervezését segítik. 39

Balrekurzió Példa: Egy bekért számnál kisebb 2 hatványok kiírása visszafelé (Szöveg kiírása betűnként visszafelé) Hatványok(K,M) Ha K<=M akkor Hatványok(2*K,M); Ki:K Eljárás vége A Rekurzív hívás az eljárás elején van Sorozat megfordítása igényli, hogy az elemeket valamilyen adatszerkezetben tároljuk (verem, de lehet tömb is). 40

Nevezetes feladatok rekurzióra Hanoi tornyai Pascal háromszög Koch-fraktál Backtrack algoritmus 8 királynő problémája 41

Programtranszformációk Rekurzió-iteráció Elöltesztelő ciklus R_iteratív(x) Ciklus amig xxx S(x) Ciklus vége Eljárás vége R_rekurziv(x) Ha xxx akkor S(x) R_rekurziv(x) Elágazás vége Eljárás vége FeltételUtasításRekurzív hívás 42

Programtranszformációk Rekurzió-iteráció Hátultesztelő ciklus R_it(x) Ciklus s(x) Amíg xxx Ciklus vége Eljárás vége R_rek s(x) Ha xxx akkor R_rek(x) Eljárás vége UFR 43

Programtranszformációk Rekurzió-iteráció számlálós ciklus~előltesztelős i=kezdet Rek_it(i,n) Ciklus amíg i<=vég ciklusmag Ciklus vége Ha i<n ciklusmag Rek_it(i+1,n) Eljárás vége 44

Programtranszformációk ItElj(X) Y=g(X) ciklus amíg p(x,y) S(X,Y) ciklus vége X=h(X,Y) Eljárás vége Rek0Elj(X,Y) Ha p(x,y) akkor S(X,Y) Rek0Elj(X,Y) Eljárás vége Rek1Elj(X) Y=g(X) Rek0Elj(X,Y) X=h(X,Y) Eljárás vége 45

Iteráció rekurzió Miez Eljárás(A,X,K,E,V) K=(E+V)div 2 Ha A[K]<X akkor E=K+1 Ha A[K]>X akkor V(K-1) Ha A[K]!=X akkor Miez(A,X,K,E,V) Eljárás vége 46

Programozási tételek rekurzív megvalósítása:összegzés 1. Szumma(I,N) Ha I<=N akkor Szumma=A[I]+Szumma(I+1,N) Különben Szumma=0; Függvény vége 2. Szumma(N) Ha N>0 akkor Szumma=Szumma(N-1)+A(N) Különben Szumma=0 Függvény vége 47

A Quicksort rendezés Hoare (1960) Módszer: A() a rendezendő sorozat, X kulcs 1. Lépés: Válasszuk az első elemet kulcsnak. X=A(0) 2. Felosztás. A tömböt két részre bontjuk úgy, hogy egy K előtt ne legyen nála nagyobb, K után ne legyen nála kisebb elem 3. A K előtti, és a K utáni részt ugyanezzel a módszerrel külön-külön rendezzük. 48

Rendezés menete X=5 5 3 2 6 9 1 4 7 X=4 4 3 2 1 9 6 5 7 i j i j 4 3 2 6 9 1 5 7 i j 4 3 2 1 9 6 5 7 j< i X=1 1 3 2 4 9 6 5 7 j< i 1 3 2 4 9 6 5 7 j= i 4 3 2 1 9 6 5 7 K=j X=3 1 3 2 4 9 6 5 7 i j 1 2 3 4 9 6 5 7 49

Quick(A, E,V) Szétválogat(A,E,V,K) Ha K-E>1 akkor Quick(A,E,K-1) Ha V-K>1 akkor Quick(A, K+1,V) Eljárás vége Algoritmus Szétválogat1(A,E,V,K) K=E; J=V; I=E; X=A[J] Ciklus amíg J>I Ciklus amíg A[J]>X J=J-1 Ciklus vége Ciklus amíg A[I]<X i=i+1 Ciklus vége Ha J>I akkor csere(a[i],a[j]) K=J Ciklus vége Egyszerű szétválogatás sok cserével Szétválogat2(A,E,V,K) K=E; J=V; X=A[K] Ciklus amíg K<J és A[J]>=X J=J-1 Ciklus vége Ha K<J akkor A[K]=A[J]; K=K+1 Ciklus amíg K<J és A[K]<=X K=K+1 Ciklus vége Ha K<J akkor A[J]=A[K]; J=J-1 Elágazás vége Ciklus vége A[K]=X Eljárás vége X a helyére kerül az eljárásban 50

Quicksort rendezés jellemzői Rendezés stabilitása: Az azonos értékű elemek ugyanabban a sorrendben jelennek meg a kimeneti tömbben, ahogy a bemeneti tömbben szerepeltek. Quicksort nem stabil rendezés Keressünk példákat stabil rendezésekre! 51

Quicksort algoritmus időbonyolultsága Legjobb eset:o(n*log(n)) Legrosszabb eset:o(n 2 ) Átlagos eset:o(k*n*log(n)) n log 2 (n!) "n*log(n) "n 2 " 1 0 0 1 10 21 33,21928 100 100 524 664,3856 10 000 1000 8 526 9 965,784 1 000 000 52

Quicksort iteratív algoritmusa veremmel 5 3 2 6 9 1 4 7 4 3 2 1 9 6 5 7 1 3 2 4 9 6 5 7 1 2 3 4 9 6 5 7 Verem: eleje, vége 1 2 4 7 0 0 Változók értékei: Eleje 0 0 0 1 Vége 7 3 2 2 Közepe 3 2 0 2 53

Gyorsrendezés iterációval verem segítségével lehet Quick(A,E,V) Verembe(0,0) Ciklus Ciklus Szétválogat(A,E,V,K) Ha V-K>1 akkor Verembe(K+1,V) V=K amíg V-E>0 Ciklus vége Veremből(E,V) Amíg E>0 Ciklus vége Eljárás vége 54

Teszt Készítsen rekurzív maximumkiválasztási algoritmust, és specifikációt! Készítsen rekurzív megszámolási algoritmust és specifikációt! 55

Objektum Orientált paradigma A szoftver krízis a szoftverfejlesztés válsága, miszerint egy hagyományos módszer (strukturált programozás) már nem képes az igényeknek megfelelő, minőségi szoftver előállítására. Cél: Olcsó Jó minőségű szoftver Szoftver elemek újrafelhasználhatósága Szoftver fejlesztés csapatmunkában (design és kód különválasztása) 56

Objektum definíció Elv: Legkisebb modul az objektum, melyben adatok és eljárások össze vannak zárva. Objektumok jellemzője: Egységbe zárás (Encapsulation) Felelősség Zártság Osztályozás Polimorfizmus Öröklődés Futás alatti kötés 57

Előzmények SIMULA67: Algol verzió, hajók modellezése objektumokkal 1969 Alan Kay egyetemista szakdolgozata az objektum orientált programozásról. 1970 Xerox Smalltalk az első tiszta objektumorientált nyelv 80-as évek: OO paradigma általánosan elfogadottá vált 58

Objektum Elv: Legkisebb modul az objektum, melyben adatok és eljárások össze vannak zárva. Objektumok jellemzője: Zártság : a mezők tárolják az információt, a metódusok kommunikálnak a külvilággal. Az osztály változóit csak a metódusokon keresztül változtathatjuk meg. Felelősség Polimorfizmus Osztályozás Öröklődés Futás alatti kötés 59

UML feladata Egységesített modellező nyelv A program osztályainak és objektumainak megtervezését, és elemzését segítő modellező nyelv Jogilag is szabványos jelölésrendszer Grafikus nyelv, azaz a modellt diagramok segítségével ábrázolja Alkalmazható a vállalatok közötti információcsere eszközeként Nincs matematikailag bizonyítva a helyessége 60

UML Unified Modeling Language 1.0 1997.01.13. Rumbaugh Booch Jacobsen Az Objektumorientált rendszer saját feladattal bíró, egymással kommunikáló objektumok összesége. Felhasználói interfész Kontroll Implementáció objektum konténer Információ hordozó 61

Osztály fogalma Az osztály: Névvel ellátott típus, ami az adattagokat és a rajtuk végzett műveleteket egységben kezeli. Class Kutya { private int lábszám; private int kg; public int Ugat(paraméterek) {kód} } adatta g Metódus Felület: műveletek összesége UML Osztály -lábszám int -kg int + Ugat() 62

Programnyelvek csoportosítása Tiszta OO nyelv pl. C# - Programozás csak oo alapon képzelhető el. Minden komponens objektum. Feladat a saját osztályok elhelyezése a hierarchiában. Hibrid nyelvek pl. Turbo Pascal, C++ - kétféle paradigma mentén is elképzelhető a programozás. Objektum alapú nyelvek pl. 63

Objektum Az osztály példányosításával keletkezik Referencia típusú változó Kutya k=new Kutya(); Általában az Osztály nevét nagy kezdőbetűvel, az objektum nevét kis kezdőbetűvel írjuk 64

Láthatóságok - Privát- private csakis az osztályon belül elérhető # Védett protected hasonló mint a private, de a leszármazott osztályok módosíthatják + Nyilvános - public mindenki láthatja Zárt sealed Nem lehet örökítéssel továbbadni Belső internal Védett, belső protected internal Osztály szintű adat vagy metódus static 65

Adattagok módosítói const értékadás deklarációkor Minden példányban ugyanaz az értéke readonly értékadás konstruktorban Példányonként lehet más-más értéke 66

Átdefiniálás (overloading) Függvények túlterhelése Ugyanolyan nevű, de különböző szignatúrájú függvényeket létrehozhatunk osztályon belül is. 67

Konstruktor kötött a neve ugyanaz mint az osztály neve (C++, Java, C#) nincs visszatérési típusa fő feladata az objektum mezőinek inicializálása végrehajtódik, mielőtt bármely metódus meghívódhatna Túlterhelhető Egyik konstruktor hívhatja a másikat Másoló konstruktor 68

Destruktor Ezen metódusok gondoskodnak arról, hogy az objektum használatának befejeztekor az objektum által lefoglalt erőforrások (memória, file- ok, háttértároló, csatolt eszközök, stb.) felszabadításra kerüljenek. Destruktor neve ~jellel kezdődik, nincs visszatérési értéke és nincs paramétere, nincs hozzáférés módosítója Nincs destruktor túlterhelés A destruktorok meghívásának három módja lehet: a. explicit módon (programozó által // desktruktor jelleg)dispose b. implicit módon (objektum megszűnésekor (ref. számláló))null c. automatikusan (objektum nincs már használatban (garbage collector = gc))referencia elveszett 69

GC A destruktor automatikus meghívásának a folyamatát szemétgyűjtési algoritmusnak nevezzük (garbage collection, GC). A garbage collector az osztály Finalize függvényét hívja meg a destruktor függvényt a fordító egy Finalize függvényre alakítja Determinált destrukciós folyamatot az ún. Dispose metódus implementálásával oldhatjuk Programozási paradigmák meg. és technikák 70

Szemétgyűjtő algoritmus Nemdeterminisztikus GC működésbe lép, ha a processzor kihasználtsága csökken GC működésbe lép, ha a rendelkezésre álló memória lecsökken GC működésbe lép, ha hívjuk. A felszabadítás sorban történik 71

Dispose() használata bool disposed=false; protected void Dispose( bool disposing ) { if(!disposed ) {if (disposing) {// ide jön az erőforrás felszabadító kód } this.disposed=true; // nem kell több hívás ha van ősosztály, akkor annak dispose hívása base.dispose( disposing );//Ős destruktor hívása GC.SupressFinalize(this);///GC kikapcsolása } } 72

Tanács C#: Általában szükséges minden általunk létrehozott osztályhoz konstruktort/kat definiálni. C#: Általában nem szükséges desktruktort definiálni, megelégedhetünk az alapértelmezettel. 73

Tulajdonság public int X { get { return x; } set { this.x = value; } } Tulajdonság egy speciális függvény Nincs paramétere Használata értékadás formájú Set és get blokk Speciális változó value Figyelem X!=x Privát adattagok hozzáférhetők biztonságos módon Csak írható, csak olvasható tulajdonságok beállíthatók 74

Felbontott típusok (partial types) //file1.cs partial class PClass { public PClass() { } } //file2.cs partial class PClass { public void. }? Hol találkozhatunk felbontott típusokkal 75

Beágyazott osztályok Egy osztály tartalmazhat más osztályokat is. A beágyazott osztály hozzáfér az őt tartalmazó osztály minden adatához. Úgy viselkedik, mint egy lokális változó Pl. form és a rajta levő vezérlők class Outer {private class Inner //a beágyazott osztály nem látható { } } class Outer //de most már igen {public class Inner {} } Outer.Inner innerclass = new Outer.Inner(); //pélányosítás 76

Fogalmak Osztály Objektum Attributum Metódus Példányosítás Inicializálás Felület Tulajdonság Konstruktor Destruktor 77

Tanácsok Ha egy programelem önálló értelmezéssel, feladattal, tulajdonságokkal rendelkezik, akkor definiáljuk ezt az elemet önálló osztályként. Ha egy programrész adata önálló objektumként értelmezhető, akkor definiáljuk őt a kívánt osztálytípus objektumaként. Ha két osztály közös tulajdonságokkal rendelkezik, akkor használjuk az öröklés lehetőségét. Általában is elmondható, hogy ha a programokban az osztályok közös vonásokkal rendelkeznek, akkor törekedni kell univerzális bázisosztály létrehozására. Gyakran ezt absztrakt bázisosztálynak is nevezzük. Az osztályok definiálásakor kerüljük a nyitott (publikus) adatmezők használatát. 78

Öröklődés - Inheritance Egy, már létező típust terjeszthetünk ki, vagy bővíthetjük tetszőleges szolgáltatással. Az eredeti osztályt ősosztálynak nevezzük (szülő base class) Az továbbfejlesztett osztályt származtatott osztálynak (gyerek derived class) Egy ősből több származtatott osztályt készíthetünk (C++) vagy, Egy származtatott osztálynak egy őse van (C#), viszont lehetőség van interfész definiálásra. 79

Öröklés példa class utódnév: ősnév { // } ősnév utódnév 80

class ős { private int i; // privát mező protected int j; // protected mezőtag public int k; // publikus mezők public void f(int j) { i=j; }; } class utód: ős { }; 81

Öröklés típusai Más programnyelvben: public, protected, privát csak szűkíteni lehet a láthatóságot! C# - csak publikus öröklés, a mezők változatlan láthatósággal adódnak tovább 82

Konstruktor, destruktor végrehajtási sorrendje Konstruktor nem öröklődik, hanem hívódik Ős. konstruktor() // ha nincs direkt őskonstruktor hívás (base) Utód.konstruktor Utód.destruktor Ős.destruktor Paraméteres konstruktor hívása: utod(paraméterek):base(paraméterek) { } 83

Lezárt osztály Sealed kulcsszó Megtiltjuk, hogy új osztályt származtassunk belőle (public sealed class kutya:allat) Lezárt függvény - nem lehet a későbbiekben átdefiniálni public sealed override void eat(){} 84

Zárt osztály nem lehet belőle leszármaztatni sealed class végleges { public végleges() { Console.WriteLine( "A konstruktor" ); } class utód:végleges // fordítási hiba { } 85

Korai kötés A példányváltozó típusa fordítási időben rögzül Metódustábla e=m; e.kiir(); //Mi történik? m.kiir(); //?? A döntést a fordító még akkor meghozza, amikor a class elso osztályt fordítja le. A döntést később már nem másíthatja meg, hiába definiáljuk felül a visszaad metódust. 86

Korai kötés A példányváltozó típusa fordítási időben rögzül Metódustábla E e=new E(); H h=new H(); E ős és H az utód, vagy H ős és E az utód? e=h; e.kiir(); //Mi történik? h.kiir() 87

Késői kötés Az OOP viselkedését, hogy egy metódus belsejében szereplő másik metódushívás másmás viselkedést mutat (más-más tényleges eljárás hívás történik a futtatás során) sokalakúságnak, polimorfizmusnak nevezzük. A példányváltozó típusa futás alatt változhat virtual-override new - sealed 88

Késői kötés A példányváltozó típusa futás alatt változhat Virtuális metódus tábla virtual-override sealed-new http://www.scribd.com/doc/26458586/programozas-cnyelven 89

Késői kötés class elso { public virtual int visszaad() { return 1; } public void kiir() { System.Console.WriteLine("Érték={0}", visszaad()); } } class masodik:elso { override public int visszaad() { return 2; } } Elso a=new elso(); Mi kerül a képernyőre? masodik b = new masodik(); a.kiir(); b.kiir(); 90

Típuskonverzió Típus lekérdezése object.gettype() Is és as Típusazonosság lekérdezéséhez (is) if (a is object) Típuskonverzióhoz (as) referenciatípusnál Castolás (Button)sender Pl. (sender as Button) referencia és érték típusnál object Button 91

Absztrakt osztály megköveteljük, hogy a leszármazott osztály implementálja a metódust abstract class os {private int e; public abstract int szamol();} class szamolo:os { public szamolo():base(3) { } public override int szamol() { } } 92

TESZT Mit csinál az alábbi program? public new void Close() { i++; this.text = i.tostring(); System.Threading.Thread.Sleep(5000); if (i < 5) Close(); else { MessageBox.Show("Most zárom!"); base.close(); } } private void button1_click(object sender, EventArgs e) { this.close(); } 93

Öröklődés - Adattagok A származtatott osztály Tartalmazza (örökli) a public mezőket és fel is használhatja Tartalmazza (örökli) a protected mezőket és fel is használhatja Tartalmazza a private mezőket, a memóriaigénybe beszámít, de nem használhatja azokat. De!! Az örökölt metódusok használhatják a privát mezőket. 94

Példa class TPont{ private int x,y; public void Balra_tol(){if(x>0) x--;} } class Tkor:Tpont{ public void KorBalratol(){ Balra_tol(); //működik? } X--; } //működik?? 95

Új adatok a származtatott osztályban class elso {private int x; protected int y; public int z; } class masodik:elso { int x; //?? int y; //?? int z; //?? } vagy class masodik:elso { int x; //?? new int y; //?? new int z; //?? } new kulcsszóval jelezzük a fordítóprogramnak: szándékos átdefiniálás! 96

Örökölt mezők II. Nem lehetséges a típus megváltoztatása De new kulcsszóval újra bevezethetjük. Átdefiniálással a mezők hatáskörét változtatjuk meg. Az örökölt mezők hatásköre az ősosztály, az átdefiniált az utódra vonatkozik. class elso {private int x; protected int y; Public int z; } Class masodik:elso { int x; //?? new float y; //?? new double z; //?? } Régi mezők elérése minősített névvel: new float z; Public akarmi() { z=1.1; //float elso.z=1; //örökölt z } 97

Öröklődés - metódusok class elso { public int visszaad() { return 1;} public void kiir() { System.Console.WriteLine( érték:{0}, visszaad()) } } class masodik:elso { new public int visszaad(){return2;} } Class Test { Static void Main(){ Masodik a=new masodik(); a.kiir(); } } Mi kerül a képernyőre? 1 v 2 98

Örökölt metódusok II. A gyerekosztályban lehet ugyanolyan nevű metódust létrehozni Ha a paraméterezése ugyanaz, használni kell a new kulcsszót Ha a szignatúra nem ugyanaz akkor nem kell a new (overloading) Az új metódust az ős osztály metódusai nem látják 99

Virtuális Metódus Tábla (VMT) Késői kötésre csak a virtuális metódusok meghívásakor kerülhet sor. Ilyenkor a fordító nem egy konkrét eljáráshívást fordít le, hanem egy utasítássorozatot, amely futás közben egy keresést hajt végre, hogy meghatározza, melyik metódusverziót kell konkrétan meghívni. (az elérhető legfrissebbet) A nyilvántartást végzi a VMT A táblázatban a metódusok indításához szükséges információk vannak eltárolva (pl. a metódusok memóriacímei, amely alapján azokat el lehet indítani) Mindig egy osztályhoz tartozik VMT Algoritmus 1. Induláskor megegyezik az ős VMT-jével. 2. Virtual kulcsszóval bevezetett metódusok bekerülnek a VMT-be (a végére) 3. Ha override kulcsszóval felüldefiniáltunk egy létező virtuális metódust, akkor a VMT bejegyzés kicserélődik az új metódusra. 100

VMT Class elso VMT Int visszaad() Void kiir() Elso.visszaad() Elso.kiir() Class masodik VMT Int visszaad() Void kiir() Masodik.visszaad() Elso.kiir() Előny: A késői kötést feloldó programkód rövid, egyszerű, gyors Hátrány VMT tábla készítése fordítási idő A példányokhoz a VMT táblát hozzá kell rendelni - futási időben a konstruktor Memóriaigény 101

class elso { public virtual int metodus_ a() {... } public virtual int metodus_ d() {... } public void metodus_ c() { metodus_ a(); } } class masodik: elso { public override int metodus_ a() {... } public virtual int metodus_ b() {... } } class elso VMT. Int metodus_ a() elso. metodus_ a Int metodus_ d() elso. metodus_ d class masodik VMT Int metodus_ a() masodik. metodus_ a Int metodus_ d() elso. metodus_ d Int metodus_ b() masodik. metodus_ b 102

A késői kötés fordítása során olyan programkód kerül fordításra, amely a VMT táblázat alapján hozza meg a döntést, hogy melyik konkrét metódust kell meghívni. Az e.metodus_c() esetén az e példányhoz az class elso VMT tábla tartozik, hiszen az e példány az elso osztály egy példánya! Ezért a késői kötés a class elso VMT tábla szerint a metodus_a() hívás esetén az elso.metodus_a() metódust kell meghívni. A m.metodus_c() esetén az m példányhoz az class masodik VMT tábla tartozik, hiszen az m példány az masodik osztály egy példánya! Ezért a késői kötés a class masodik VMT tábla szerint a metodus_a() hívás esetén a masodik.metodus_a() metódust kell meghívni. 103

Dinamikus Metódus Tábla A szerepe megfelel a VMT-nek (késői kötés feloldását támogatni) Kevesebb memóriaigénye van, mint a VMT-nek Lassúbb a kezelése Felépítése: Hasonló, mint a VMT Osztályhoz van hozzárendelve A DMT induláskor üres Ha az osztályban bevezetünk egy új virtuális metódust a virtual kulcsszóval, akkor ezen metódus bekerül a táblázatba (a végére) Ha az osztályban felüldefiniáltunk egy már létező virtuális metódust az override kulcsszóval, akkor ez is bekerül a táblázatba 104