Bánsághi Anna 2014 Bánsághi Anna 1 of 68

Objektumok, osztályok

8. előadás

IMPERATÍV PROGRAMOZÁS © Bánsághi Anna [email protected]

8. ELŐADÁS - OBJEKTUMOK, OSZTÁLYOK

2014 © Bánsághi Anna

1 of 68


8. előadás

TEMATIKA I. ALAPFOGALMAK, TUDOMÁNYTÖRTÉNET II. IMPERATÍV PROGRAMOZÁS Imperatív paradigma Procedurális paradigma Generikus paradigma III. STRUKTÚRÁLT PROGRAMOZÁS Objektumorientált paradigma Moduláris paradigma


2 of 68


8. előadás

III. STRUKTÚRÁLT PROGRAMOZÁS OBJEKTUMORIENTÁLT PARADIGMA 1. Absztrakt adattípus 2. Objektumok, osztályok Objektumorientált alapok Osztályok, objektumok Egységbezárás Nyílt rekurzió Névterek 3. OOP tervezés 4. Öröklődés 5. Adatszerkezetek megvalósítása


3 of 68


8. előadás

1. OBJEKTUMORIENTÁLT ALAPOK FELVEZETŐ FELADAT Számítsuk ki egy téglalap, egy négyzet és egy kör kerületét és területét nem vezethető vissza semmilyen programozási tételre helyette használjuk az adatabsztrakciót, azaz térjünk át rögtön a lehetséges típusok keresésére típusértékek ~ főnevek ~ téglalap, négyzet, kör műveletek ~ igék ~ kerületszámítás, területszámítás


4 of 68


8. előadás

TÍPUSOK - ELSŐ KÖZELÍTÉS Három típusunk lesz: Téglalap, Négyzet, Kör


értékhalmaz művelethalmaz

{ téglalapok } { Kerület, Terület }


{ négyzetek } { Kerület, Terület }


{ körök } { Kerület, Terület }

5 of 68


8. előadás

EGY LEHETSÉGES ÁBRÁZOLÁS struct Téglalap { ..., double Kerulet(), double Terulet() } struct Négyzet { ..., double Kerulet(), double Terulet() } struct Kör { ..., double Kerulet(), double Terulet() }

érezzük, hogy a típusok hasonlítanak egymásra, jobb lenne együttesen kezelni őket


6 of 68


8. előadás

A FELADAT ÁLTALÁNOSÍTÁSA Számítsuk ki különféle síkidomok kerületét és területét típusértékek ~ főnevek ~ síkidomok műveletek ~ igék ~ kerületszámítás, területszámítás a típusértékhalmaz általánosítása jó lépésnek tűnik, benne van a lehetőség egy későbbi bővítésre is (háromszögek, ...)


7 of 68


8. előadás

TÍPUSOK - MÁSODIK KÖZELÍTÉS Egyetlen típusunk lesz: Síkidom értékhalmaz művelethalmaz

{ síkidomok } { Kerület, Terület }

EGY LEHETSÉGES ÁBRÁZOLÁS struct Síkidom { ..., double Kerulet(), double Terulet() } ... var síkidomok = new List<Síkidom>

elveszett az információ, hogy éppen milyen síkidomról van szó, melyik képletet kell alkalmazni


8 of 68


8. előadás

ALTÍPUSOS POLIMORFIZMUS szükségünk van egy olyan nyelvi eszközre, amellyel egy típusértéket (pl. téglalap) több típushoz tartozónak tekinthetünk, hol a speciálisabb típusa (Téglalap), hol az általánosabb típusa (Síkidom) jut érvényre, a programkörnyezettől függően téglalap ∈ Téglalap téglalap ∈ Síkidom a típusértékek többalakúak, több típushoz is tartozhatnak


9 of 68


8. előadás

SÍKIDOMOK OSZTÁLYOZÁSA

egy lehetséges típushierarchia a síkidomok tulajdonságai alapján minden leszármazott tartalmazza az őt befoglaló jellemzőit minden leszármazott specializáltabb, mint az őt befoglaló


10 of 68


8. előadás

ÖRÖKLŐDÉS szükségünk van egy olyan nyelvi eszközre, amellyel ki tudjuk fejezni a típushierarchiát a típusok közötti altípusképzési műveletet öröklődésnek nevezzük téglalap ∈ Téglalap ⊂ Síkidom az altípus örökli az őstípus összes jellemzőjét és műveletét


11 of 68


8. előadás

ÖRÖKLŐDÉSI HIERARCHIA


12 of 68


8. előadás

TÍPUSÉRTÉKEK BELSŐ ADATAI a típusértékek egyedi jellemzőkkel bírnak egy Téglalap típusú síkidomot a szomszédos oldalainak hossza jellemez egy Kör típusú síkidomot a sugarának hossza jellemez szükségünk van egy olyan nyelvi eszközre, mely biztosítja, hogy a típusértékek belső adataihoz (a mezők értékeihez) csak az adott típus műveletein keresztül lehessen hozzáférni


13 of 68


8. előadás

EGYSÉGBEZÁRÁS ÉS NYÍLT REKURZIÓ a típusértékek adatait és az ezen adatokon végrehajtott műveleteket egyetlen egységként kezeljük a belső adatok és a műveletek ábrázolásának elrejtésével biztosítható, hogy a külvilág ne férjen hozzá egy típusérték belső adataihoz egy téglalap ∈ Téglalap objektum tudni fogja, hogy mekkorák az oldalai, viszont a külvilág csak a kerületét és a területét kérdezheti le, hiszen ezek a megengedett típusműveletek


14 of 68


8. előadás

OBJEKTUMORIENTÁLTSÁG TÉNYEZŐI absztrakció az objektum reprezentációs szintjének megválasztása egységbezárás az adatok és alprogramok egységbe zárása, a belső működés elrejtése nyílt rekurzió az objektum mindig látja saját magát, eléri műveleteit és adatait öröklődés az objektum tulajdonságainak átruházása más objektumokra polimorfizmus és dinamikus kötés a műveletek futási időben történő működéshez kötése


15 of 68


8. előadás

A STRUCT ÉS A CLASS NYELVI SZERKEZETEK a struct egyszerű adatszerkezetek megvalósítására szolgál, az objektumok általában változatlanok maradnak a létrehozás után a class komplex adatszerkezetek megvalósítására szolgál, az objektumok általában megváltoznak a program futása során


16 of 68


8. előadás

KÜLÖNBSÉGEK ÉS HASONLÓSÁGOK struct

class

értéktípus referencia típus ∅ öröklődés ∅ altípusos polimorfizmus egységbezárás egységbezárás ∅ felüldefiniálható a paraméter nélküli konstruktor


17 of 68


8. előadás

2. OSZTÁLYOK, OBJEKTUMOK az objektumelvű paradigma a feladatot együttműködő, egymással kommunikáló objektumokkal modellezi az adattípusok megvalósításának célja, hogy az összetett szerkezetű adatok is jól, könnyen kezelhetővé váljanak ha csak egy programon használnánk az új adattípust, akkor nem feltétlenül térülne meg a befektetett energia, ezért a típusok újrafelhasználhatóságára törekszünk


18 of 68


8. előadás

OBJEKTUMORIENTÁLT FOGALMAK osztály

~ típus

objektumok

~ típusértékek

tagok

~ típusérték adatai és műveletei

objektum állapota ~ típusérték belső adatainak értéke


19 of 68


8. előadás

PROGRAM VÉGREHAJTÁSA


20 of 68


8. előadás

OBJEKTUMORIENTÁLT PROGRAM program, melyet egymással kommunikáló objektumok összessége alkot minden adat egy objektumhoz tartozik, és minden algoritmus egy objektumhoz rendelt tevékenység, nincsenek globális adatok vagy globális algoritmusok a program így kellő tagoltságot kap az objektumok mentén az adatok élettartama így összekapcsolható az objektum élettartamával a módosítások általában az objektum belsejében véghezvihetők, ami nem befolyásolja a többi objektumot, így nem szükséges jelentősen átalakítani a programot


21 of 68


8. előadás

AZ OBJEKTUM egy rendszer egyedileg azonosítható szereplője, amelyet belső struktúrájával, aktuális állapotával és a külvilág felé mutatott viselkedésével jellemezhetünk reagál a neki küldött üzenetekre, azaz megváltoztatja az állapotát, elvégez valamilyen műveletet, információt ad a külvilágnak, üzenetet küld más objektumoknak információt tárol és kérésre feladatot hajt végre, tehát az objektum adatok és műveletek összessége


22 of 68


8. előadás

OBJEKTUMOK ÁLLAPOTA az objektum állapotát mezőértékeinek összessége adja két objektum állapota ugyanaz, ha értékeik megegyeznek (ettől függetlenül az objektumok különböznek) az objektum állapota valamilyen esemény (műveletvégzés, kommunikáció) hatására változhat meg a teljes program állapotát a benne lévő objektumok összállapota adja meg


23 of 68


8. előadás

OBJEKTUMOK TULAJDONSÁGAI

egyedi azonosító aktuális állapot (mezők aktuális értéke) a metódusok listája


24 of 68


8. előadás

OBJEKTUMOK DINAMIKUS VISELKEDÉSE

objektumokat érő hatások és azok sorrendje a metódusok végrehajtásának ütemezése állapotváltozások folyamata


25 of 68


8. előadás

AZ OSZTÁLY az objektumok viselkedési mintáját tartalmazza, az osztályból példányosíthatjuk az objektumokat az osztály az objektum típusa az osztályban tárolt adatokat konstansoknak, mezőknek, tulajdonságoknak nevezzük az osztály által elvégezhető műveletek a konstruktorok, destruktorok, metódusok, operátorok az osztály adatait és műveleteit együttesen tagoknak nevezzük a tagok láthatósága szabályozható, a kívülről látható rész az interfész, a kívülről nem látható rész az implementáció a műveletek megvalósítása az implementáció része, tehát más osztályok számára a működés mindig ismeretlen


26 of 68


8. előadás

AZ OSZTÁLY

ugyanazon tagokkal rendelkező objektumok típusa minden objektum valamilyen osztály egy példánya


27 of 68


8. előadás

OBJEKTUMOK ÉLETTARTAMA létrejön

memóriafoglalás mezők inicializálása

futási idejű környezet konstruktor new

él

állapotváltozások

saját metódusok végrehajtása

üzenetküldések

más objektumokon metódushívások

megszűnik rendrakás szemétgyűjtő/destruktor delete, ~ memóriafelszabadítás futási idejű környezet


28 of 68


8. előadás

LÉTREJÖN PÉLDÁNYOSÍTÁSSAL NEW


29 of 68


8. előadás

KONSTRUKTOROK minden osztály rendelkezik legalább egy, paraméter nélküli konstrukciós művelettel a művelet neve megegyezik az osztály nevével beállítja az új objektum kezdőállapotát class OsztalyNev {...} OsztalyNev objektum = new OsztalyNev();

// a két értékeadás ekvivalens int i = 0; int i = new int();


30 of 68


8. előadás

MEGSEMMISÜL DESTRUKTORRAL VAGY AU‐ TOMATIKUSAN public class Pont {...} public class Gomb {...} public class Urteleszkop { public static void Main() { Gomb gomb

= new Gomb( new Pont(0,0,0), 10 );

Pont pont1 = new Pont(12, 1, 3); Pont pont2 = new Pont(3, 4, 5); Pont pont3 = new Pont(2, 2, 3); }

// létrejön a gömb

// létrejön a pont1 objektum // létrejön a pont2 objektum // létrejön a pont3 objektum

// Mi történik az objektumokkal a végrehajtásnak ezen a pontján?

}


31 of 68


8. előadás

A GÖMB OBJEKTUM A MEMÓRIÁBAN blokkon belül elérhető a gömb nevű referencián keresztül

blokkon kívül elérhetetlen, nincs rá érvényes referencia

PROBLÉMA, HOGY OTT MARAD SZEMÉTKÉNT A MEMÓRIÁBAN


32 of 68


8. előadás

DESTRUKTOR minden osztály rendelkezik egyetlen destrukciós művelettel az objektum megszűnésekor automatikusan hívódik meg csak egyetlen, paraméter nélküli destruktor létezhet class OsztalyNev { ~OsztalyNev() {...} }


33 of 68


8. előadás

FUTÁSI IDEJŰ KÖRNYEZET VIRTUÁLIS GÉP az OO programok végrehajtását menedzselő környezet

FELADATAI forráskód fordítása a számítógép által végrehajtható kóddá dinamikus és hatékony memóriagazdálkodás típusellenőrzés, futási idejű típuskonverzió automatikus szemétgyűjtés kivételkezelés szálkezelés


34 of 68


8. előadás

OBJEKTUMOK MEGSEMMISÍTÉSE a lefoglalt memóriarekeszeket előbb-utóbb fel kell szabadítani

AUTOMATIKUS SZEMÉTGYŰJTÉS a hivatkozás nélküli objektumokat (nincs rájuk mutató vagy érvényes referencia) a környezet automatikusan, nemdeterminisztikus időközönként felszabadítja

PROGRAMOZÓ ÁLTALI MEMÓRIA FELSZABADÍTÁS explicite is kezdeményezhető a szemétgyűjtés objektumok megszüntetése destruktorokkal


35 of 68


8. előadás

3. EGYSÉGBEZÁRÁS rekord / osztály belsejében a mezők mellett definiálhatunk műveleteket, melyek közvetlenül az adott típusú változóhoz fognak kötődni amikor deklarálunk egy változót, akkor a műveletek automatikusan értelmezésre kerülnek rajta a típus műveleteinek beágyazását a rekordba / osztályba nevezzük egységbezárásnak a műveleteket csak változón keresztül érhetjük el, tehát kell, hogy legyen egy példányunk a típusból, melyen meghívhatjuk az adott típusműveletet


36 of 68


8. előadás

A TÉGLALAP TÍPUSSPECIFIKÁCIÓJA R × R = R2


Téglalap = ( R

2


{ Téglalap : → Téglalap, Téglalap : R × R → Téglalap, Kerület : R × R → R, Terület : R × R → R }

, { Téglalap, Kerület, Terület } )

37 of 68


8. előadás

TÉGLALAP OSZTÁLYDIAGRAMJA


38 of 68


8. előadás

A TÉGLALAP MEGVALÓSÍTÁSA public class Teglalap { // mezők: public double a; public double b; // konstruktorok: public Teglalap() { a = b = 10; } public Teglalap( double oldal1, double oldal2 ) { a = oldal1; b = oldal2; } // metódusok: public double Kerulet() { return 2 * a + 2 * b; } public double Terulet() { return a * b; } }


39 of 68


8. előadás

A TÉGLALAP PÉLDÁNYOSÍTÁSA public static void Main() { // "Teglalap" típusú példányváltozó (objektum) létrehozása Teglalap teglalap = new Teglalap( 2, 3 ); // az objektumhoz kötött típusműveletek hívása az objektumon double kerulet = teglalap.Kerulet(); double terulet = teglalap.Terulet(); Console.WriteLine( "A {0}x{1}-as téglalap kerülete: {2}", teglalap.a, teglalap.b, kerulet ); }


40 of 68


8. előadás

HATÓKÖR, ÉLETTARTAM, LÁTHATÓSÁG a hatókör a programnak az a része, ahol egy adott programelem (változó, objektum, alprogram, osztály) látható, elérhető, felhasználható az élettartam a program futási idejének az az intervalluma, amikor egy adott programelem elérhető, felhasználható


41 of 68


8. előadás

HATÓKÖRÖK a teljes program egy fordítási egység egy névtér egy osztály egy alprogram egy kódblokk a hatókörök egymásba is ágyazhatók


42 of 68


8. előadás

HATÓKÖRÖK public class C1 { static int i = 3; public static void Eljaras( int j ) { j *=2; } public static int Fuggveny() { i = 12; if( i > 10) { int j = 4; Eljaras(j); } return i; }

// C1.Eljaras // Eljaras-ra lokális j // C1.Fuggveny // C1.i // if blokkra lokális j

} public class C2 { public static void Main() { int i = 5; C1.Fuggveny(); } }


// Main-re lokális i

43 of 68


8. előadás

STATIKUS ÉLETTARTAM globális vagy névtérbeli változó, illetve statikus adattag létrejön a programegység elején megszűnik a programegység végén public class StatikusElettartam { public const string s = "konstans"; static int i;

// inicializáció: s // inicializáció: i

public static void Main() { . . . }

// megsemmisülés: i, s

}


44 of 68


8. előadás

AUTOMATIKUS ÉLETTARTAM automatikus, névvel rendelkező programelem létrejön a deklaráció kiértékelésekor megszűnik, amikor a vezérlés elhagyja a deklaráló blokkot public class AutomatikusElettartam { static void Eljaras() { int i = 2; . . . }

// initializáció: i // megsemmisülés: i

public static void Main() { Eljaras(); } }


45 of 68


8. előadás

DINAMIKUS ÉLETTARTAM dinamikus objektum a szabad memóriában létrejön a new operátorral megszűnik a delete operátorral ha van ilyen public class DinamikusElettartam { public static void Main() { DateTime d = new DateTime(2010,1,18); . . . d = null; . . . }

// initializáció: d // "megsemmisülés": d

}


46 of 68


8. előadás

LÁTHATÓSÁG KEZELÉS rekord / osztály mezőit célszerű védeni a külvilágtól az egymástól függő mezők inkonzisztens állapotba hozhatják az objektumot, pl. negatív értékű oldalhossz egy Téglalap típusú objektum esetén a láthatóság szabályozásával elrejthetjük a tagokat a külvilág elől, így rejtett tagra való hivatkozás esetén fordítási hibát kapunk általában a mezőket és a segédműveleteket elrejtjük, de a konstruktorok nyilvánosak, különben nem tudnánk példányosítani


47 of 68


8. előadás

TAGOK LÁTHATÓSÁGI KÖRE + public

az osztályon vagy más struktúrán kívül és belül teljes mértékben hozzáférhető

# protected

csakis a tartalmazó osztályon és annak leszármazottain belül látható

- private

csakis a tartalmazó osztályon belül látható, a leszármazottak sem láthatják alapértelmezett láthatóság

~ internal

ugyanazon fordítási egységhez tartozó fájlokban látható


48 of 68


8. előadás



49 of 68


8. előadás

A Téglalap megvalósítása hozzáférhetetlen mezőkkel public class Teglalap { // mezők: private double a; private double b; // konstruktorok: public Teglalap() {...} public Teglalap( double oldal1, double oldal2 ) {...} // metódusok: public double Kerulet() {...} public double Terulet() {...} }


50 of 68


8. előadás

MEZŐK ÉS TULAJDONSÁGOK ha mégis biztosítani akarjuk a mezők nyilvános hozzáférését, akkor azt speciális tulajdonságokkal tehetjük a mezőneveket kisbetűvel kezdjük, a tulajdonságok neve megegyezik a nagybetűvel kezdődő mezőnévvel private double a;

// rejtett mező

public double A { get { return a; } set { a = value; } }

// nyilvános tulajdonság // mező értékét lekérdező


// mező értékét beállító

51 of 68


8. előadás

AUTOMATIKUS TULAJDONSÁGOK a fenti rejtett mező - nyilvános tulajdonság koncepció nagyban megnöveli a kód hosszát ha a tulajdonság lekérdezés vagy beállítás nem tartalmaz további logikát, akkor használhatjuk az automatikus megvalósítású tulajdonságokat public double A { get; set } // nyilvános tulajdonság

a C# fordítási környezet számos funkcionalitást biztosít a tulajdonságokhoz


52 of 68


8. előadás

A TÉGLALAP MEGVALÓSÍTÁSA TULAJDONSÁGOKKAL legyenek a téglalap oldalai kívülről lekérdezhetők, de nem módosíthatók legyen a téglalapnak egy új tulajdonsága, a szín, amely kivülről is módosítható és lekérdezhető használjunk mezők helyett automatikus tulajdonságokat


53 of 68


8. előadás



54 of 68


8. előadás

TÉGLALAP OSZTÁLY public class Teglalap { // automatikus tulajdonságok: public double A { get; private set; } public double B { get; private set; } public string Szin { get; set; } // konstruktor: public Teglalap( double a, double b, string szin ) { A = a; B = b; Szin = szin; } // metódusok: public double Kerulet() { return 2 * A + 2 * B; } public double Terulet() { return A * B; } }


55 of 68


8. előadás

FŐPROGRAM public static void Main() { Teglalap teglalap = new Teglalap( 2, 3, "zöld" ); teglalap.Szin = "piros"; // módosítható a Szin Console.WriteLine( teglalap.Szin ); // lekérdezhető a Szin //teglalap.B = 13; Console.WriteLine( teglalap.B );

// fordítási hiba, nem módosítható a B oldal // lekérdezhető a B olal

}


56 of 68


8. előadás

4. NYÍLT REKURZIÓ az osztálydefinícióban a műveleteken belül mindig hivatkozhatunk magára az objektumra this kulcsszóval a this egy referencia, és arra az objektumra mutat, amelyiken meghívtuk az adott műveletet műveleten kívül és statikus műveletekbe nem szabad írni segítségével hívhatók meg egymásból a konstruktorok függvény visszatérési értéke, hogyha egymás után láncolható műveleteket (fluent interface) akarunk megvalósítani


57 of 68


8. előadás

TÉGLALAP OSZTÁLY public class Teglalap { // automatikus tulajdonságok: public double A { get; private set; } public double B { get; private set; } public string Szin { get; set; } // konstruktor: public Teglalap( double a, double b, string szin ) { this.A = a; this.B = b; this.Szin = szin; } // metódusok: public double Kerulet() { return 2 * this.A + 2 * this.B; } public double Terulet() { return this.A * this.B; } }


58 of 68


8. előadás

KONSTRUKTOR HÍVÁSA MÁSIK KONSTRUKTORBÓL public class Teglalap { // automatikus tulajdonságok: public double A { get; private set; } public double B { get; private set; } public string Szin { get; set; } // konstruktorok: public Teglalap() { this.A = this.B = 10; this.Szin = "kék"; } public Teglalap( double a, double b ) : this() { this.A = a; this.B = b; } public Teglalap( double a, double b, string szin ) { this.A = a; this.B = b; this.Szin = szin; } }


59 of 68


8. előadás

KONSTRUKTOR HÍVÁSA MÁSIK KONSTRUKTORBÓL public static void Main() { var t1 = new Teglalap( 2, 3, "zöld" ); var t2 = new Teglalap( 2, 3 ); Console.WriteLine( t1.Szin ); // Mi lenne t2.Szin értéke, ha nem hívnánk meg // a paraméter nélküli konstruktort is? Console.WriteLine( t2.Szin ); } }


60 of 68


8. előadás

TÉGLALAP DUPLÁZ, FELEZ MŰVELETEKKEL Valósítsuk meg a Dupláz és a Felez műveleteket, melyek a téglalap oldalainak hosszát módosítják public class Teglalap { // automatikus tulajdonságok: // ... // konstruktorok: // ... // metódusok: // ... public Teglalap Duplaz() { this.A *= 2; this.B *= 2; return this; } public Teglalap Felez() { this.A /= 2; this.B /= 2; return this; } }


61 of 68


8. előadás

FŐPROGRAM DUPLÁZ, FELEZ MŰVELETEKKEL public static void Main() { var teglalap = new Teglalap( 20, 30 ); Console.WriteLine( "Az 'a' oldal eredetileg: {0}", teglalap.A ); Console.WriteLine( "Az 'a' oldal duplázva: {0}", teglalap.Duplaz().A ); Console.WriteLine( "Az 'a' oldal felezve: {0}", teglalap.Felez().A ); Console.WriteLine( "Az 'a' oldal 2x felezve: {0}", teglalap.Felez().Felez().A ); }


62 of 68


8. előadás

TÉGLALAP MÓDOSÍT MŰVELETTEL Valósítsuk meg a Módosít műveletet, mely paraméterben kapja, hogy hányszorosára módosítsa az oldalakat public class Teglalap { // automatikus tulajdonságok: // ... // konstruktorok: // ... // metódusok: // ... public Teglalap Modosit( double szorzo ) { this.A *= szorzo; this.B *= szorzo; return this; } }


63 of 68


8. előadás

FŐPROGRAM MODÓSÍT MŰVELETTEL public static void Main() { var teglalap = new Teglalap( 20, 30 ); Console.WriteLine( "Az 'a' oldal eredetileg: {0}", teglalap.A ); Console.WriteLine( "Az 'a' oldal duplázva: {0}", teglalap.Modosit(2).A ); Console.WriteLine( "Az 'a' oldal felezve: {0}", teglalap.Modosit(0.5).A ); Console.WriteLine( "Az 'a' oldal negyedelve: {0}", teglalap.Modosit(0.25).A ); }


64 of 68


8. előadás

5. NÉVTEREK az egymással összefüggő típusokat célszerű névterekbe rendezni, és külön fájlokba csomagolni így azok újrafelhasználhatók lesznek bármely másik programban vagy típusban, miközben csökken a kód bonyolultsága is az önálló fordítási egységben lévő névtereket a using kulcsszóval vehetjük használatba a fordítóprogram szerkeszti össze a számos fordítási egységből álló programot a névterek egymásba ágyazhatók


65 of 68


8. előadás

A FŐPROGRAM SZERKEZETE using System; using System.Collections; using EgyikNévtér;

// használatba vesszük a külső fájlokban // elhelyezett kódot

namespace FoprogramNevtere { public class Osztaly1 {...} public class Osztaly2 { public static void Main() {...} } }

// a Main főprogramot tartalmazó névtér

namespace MasikNevter { public class Osztaly1 {...} public class Osztaly2 {...} }

// fordítási egységen belüli névtér


// pontosan egy Main metódus

66 of 68


8. előadás

SÍKIDOMOK NÉVTERE Készítsük el a Síkidomok névterét önálló fordítási egységben namespace Sikidomok { public class Teglalap { public double A { get; private set; } public double B { get; private set; } public string Szin { get; set; } public Teglalap() {...} public Teglalap( double a, double b, string szin ) {...} public double Kerulet() {...} public double Terulet() {...} } }


67 of 68


8. előadás

Főprogram using System; using Sikidomok; namespace Foprogram { public class SikidomokPelda { public static void Main() { var teglalap = new Teglalap( 2, 3, "zöld" ); Console.WriteLine( teglalap.Szin ); } } }


68 of 68

Bánsághi Anna 2014 Bánsághi Anna 1 of 68

Recommend Documents