C# osztályok

C# osztályok

Krizsán Zoltán

1.0

Krizsán Zoltán, iit C# osztályok 2

Fogalma

Önálló hatáskörrel rendelkező, absztrakt adattípus, amely több, különböző elemet tartalmazhat.

Minden esetben a heap-en jön létre! A programozó hozza létre, de a GC

menedzseli.


Definíció

[attributes] [modifiers] class <className> [: baseClassName] { [class-body] }[;]

Módosítók lehetnek: new, public, protected, internal, private, abstract, sealed

Hasonló, mint C++-ban, vagy JAVA-ban, nem kötelező a „;” a végén

Nincs jelölve, de minden osztály a System.Object származottja


Mezők tárolási módjai

Statikus:Egy példány minden objektum számára, osztályhoz kötődik, nem az objektumhoz!

Példány:Minden objektumnak külön példánya van a tagból.


Mezők hozzáférési módosítói

A tagok elérési szabályozza, minden mező elé ki kell tenni!

private (alapértelmezett): csak az adott osztályból érhető el.

protected: az adott osztályból, és a leszármazottakból érhető el.

internal: csak a szerelvény fv.-ei érhetik el protected internal: az előző kettő összege public: nincs semmilyen korlátozás, minden

szerelvényből


Osztály részei

Adattagok (Field) - adatok Konstansok (Constant) – állandó adatok Csak olvasható mezők (read only)

Tagfüggvények (Method) – fv.-ek Operátorok (Operator) – speciális tfv.-ek Indexelők (Indexer) – speciális tfv.-ek

Tulajdonságok (Property) – kivűlről adat, belülről fv.

Delegátumok – típusos fv. Pointer osztály Események (Event) – delegátumok


Adattagok

Osztály hatáskörben definiált változó. Formája:

[attribútum] [módosító] típus azonosító [=kezdő érték][, azonosító [=kezdő érték]];

Módosítók lehetnek:const – konstansreadonly – csak olvasható mezőstatic – statikusvolatile – gyakran változó


Konstans

Értéke fordítási időben állítódik be, futási időben értéke nem változtatható.

Csak konstans értékét veheti fel. Alapértelmezett tárolási osztálya static. Nem kell példányosítani az osztályt ahhoz,

hogy használjuk MSIL kódban lcd utasítás (load constant) tölti

fel a stack-re.


Csak olvasható mezők

Futási időben állítható az értéke, de csak egyszer!

Értékét 3 helyen állíthatjuk:konstruktor, statikus konstruktor, vagy a definíció során.

Értékét akár fv. hívás visszatérési értéke is szolgáltathatja!

Az osztály különböző példányaiban a mező különböző étéket vehet fel.


Osztály részei



Tulajdonságok (Property) – kivülről adat, belülről fv.

Delegátumok – típusos fv. pointerek Események (Event) – delegátumok


Tagfüggvény

Osztályban definiált függvény C#-ban nem definiálhatunk globális függvényt! Formája:

[attribútum] [módosítók] visszatérési_érték fvnév([paraméterszignatúra])

Egy módosító csak egyszer szerepelhet. Kölcsönösen kizárják egymást:

static, virtual, override Kölcsönösen kizárják egymást:

new, override


Tagfüggvény változó hosszúságú paraméterlista

class OpenEnded{ public void Foo( params object[] pp ){

for (int i = 0 ; i < pp.GetLength(0) ; i++){ Console.WriteLine(pp[i]);

} }

} class TestVarArgs{

static void Main(string[] args){ OpenEnded oe = new OpenEnded(); oe.Foo( 123, 456, "Hello", new Point(7,8),

9.0m, true, 'X‘); }

}


Tagfüggvényparaméter átadás módjai

void ertekSzerint(int a)beállított értéket kap

void referenciaSzerint(ref int a) hívásnál is kell a ref kulcsszó, kötelező

inicializálni void kimenetiRefSzerint(out int a)

hívásnál is kell az out kulcsszó, kötelező a fv. törzsben beállítani


TagfüggvényMain fv. alakjai

public static void Main() {...}public static void Main(string[] args) {...}public static int Main() {...}public static int Main(string[] args) {...}


TagfüggvényVirtuális fv.

Alapból nem virtuális (nem úgy, mint JAVA) virtual kulcsszó segítségével. Ha egy fv. virtuális, akkor kötelező definiálni a

törzsét Felülírása az override minősítővel a

leszármazott osztályok valamelyikében Teljes azonosság


TagfüggvényKonstruktor

Neve: osztálynév Nem lehet meghívni explicite, de meghívódik

amikor a rendszer létrehozza az objektumot. Default konstruktor itt is van. Ha nincs konstruktor itt is létrejön egy, és ez

0, false, null-ra állít Hívható másik konstruktor, akár az

ősosztályé is, de a formája a következő:public Employee(int weeklySalary, int

numberOfWeeks) : this(weeklySalary) { }


TagfüggvényDestruktor

Neve: ~osztálynév Csak 1 darab lehet. Ami finalize-re

konvertálódik. Nem öröklődik, és nem lehet felüldefiniálni. Nem lehet meghívni explicite, de meghívódik

amikor a gc felszabadítja, kisöpri az objektumot.

Nem lehet sem paramétere, sem módosítója.


Külső fv.

Akkor mégis van??????????? Nem lehet definiálni, de lehet használni

mások által definiált dll fv.-eket.

[DllImport("kernel32", SetLastError=true)]

static extern bool CreateDirectory(string name,

SecurityAttribute sa);


Operátorok

KétoperandusúEgyik legalább osztály típusú

EgyoperandusúOsztály típusú prefix postfix


Szintaktikai szabályok

Statikus fv.-nek kell lennie (static)! Publikusnak kell lennie (public)! Neve kötelezően operator utána egy jel Egyoperandusú op.-nál a fv. paramétere kötelezően az adott

osztály típusú kell legyen! Kétoperandusú op.-nál a fv. egyik paramétere kötelezően az

adott osztály típusú kell legyen! Nem definiálható felül a [] operátor (de ott vannak az indexerek).


Szintaktikai szabályok

() operatort nem lehet &&, || , ?: logikai operatorokat nem lehet == sem lehet, de az Equals fv.-t viszont felül

lehet írni! new, =, . Sem lehet <, > operátorokat csak párban lehet

újradefiniálni! Nem létező operátorokat nem lehet

újradefiniálni!


Példa – egyoperandusú operátor

struct RGBColor{public static readonly RGBColor EMPTY = new RGBColor(0x00);public static readonly RGBColor FULL = new RGBColor(0xFF); int colorValue; public int ColorValue{ get { return colorValue; } } public RGBColor(int color){ colorValue = color; } public static RGBColor operator++(RGBColor color) {

if (color.colorValue != FULL) color.colorValue++; return color;

}public static RGBColor operator- -(RGBColor color) {

if (color.colorValue != EMPTY) color.colorValue--;return color;

}public string ToString(string format){

return (colorValue.ToString(format)); } }


Példa – aritmetrikai operátor

public static bool operator<(RGBColor color1, RGBColor color2)

{

return color1.colorValue < color2.colorValue;

}

public static bool operator>(RGBColor color1, RGBColor color2)

{

return color1.colorValue > color2.colorValue;

}


Példa – kétoperandusú operátor

public static RGBColor operator+(RGBColor color, int inc) {if (0xFF >= (color.colorValue + inc))

color.colorValue += inc; else

color.colorValue = 0xFF; return color;

} public static RGBColor operator-(RGBColor color, int dec)

{ if (0 < (color.colorValue - dec)) color.colorValue -= dec;

else color.colorValue = 0x00;

return color; }


Példa

struct RGB{public RGB(RGBColor red, RGBColor green, RGBColor blue){

Red = red;Green = green;Blue = blue;

}public RGBColor Red;public RGBColor Green;public RGBColor Blue;public override string ToString(){

return (Red.ToString("X2") + Green.ToString("X2")+ Blue.ToString("X2"));

}}


Példa – teszt osztály

class GradientFill{static void PrintRGBValue(RGB rgb) {

Console.WriteLine("{0} ", rgb);}public static void Main(){

Console.WriteLine("Getting RGB values for gradient " +"fill (dark red -> red)\n");

for (RGB rgb = RGB.DARKRED; rgb.Red.ColorValue < 0xFF; rgb.Red++ ){PrintRGBValue(rgb);

}}

}


Konverziós operátorok

Alakja: public static kulcsszó operator mire(mit) Kulcsszó lehet:

ImplicitAutomatikusan lefut.Sikeresnek kell lennie!Akkor ajánlott, ha nem jár inf. veszteséggel

Explicit Nem fut le automatikusan.Hív(ód)ás:

(típus) kifejezés -> kivételt dobhat! Kif as típus -> Nem dobhat kivételt (null)!


Példa II

public static implicit operator int (RGBColor col)

{

return col.colorValue;

}

Tesztben csere:

…

for (RGB rgb = RGB.DARKRED;

rgb.Red.ColorValue < RGBColor.FULL;

rgb.Red++){…}

…


Példa - konverziós operátor

struct Celsius{ public Celsius(float temp){

this.temp = temp; } public static implicit operator Celsius(float temp){

Celsius c; c = new Celsius(temp); return(c);

} public static implicit operator float(Celsius c){

return((((c.temp - 32) / 9) * 5)); // Fahrenheit-be vissza } public float temp;

}


Osztály részei



Tulajdonságok (Property) – kivűlről adat, belülről fv.

Delegátumok – típusos fv. pointerek Események (Event) – delegátumok


Tulajdonságok

Kívülről adattag belülről tfv. Lehet csak írható, lehet csak olvasható Nem lehet fv. paramétere! Absztrakt osztály segítségével

kikényszeríthető a léte! Lehet virtuális.


Szintaktika

[attributes] [modifers] <type> <property-name>

{

[ set {

<accessor-body>

} ]

[ get {

<accessor-body >

} ]

}


Példa

class Address{protected string city; public string City{ get{ return city; } } //csak olvashatóprotected string zipCode; public string ZipCode{

get { return zipCode; } set { zipCode = value; city = "Atlanta";}

} } class PropertyApp{

public static void Main(){ Address addr = new Address(); addr.ZipCode = "30338"; string zip = addr.ZipCode;Console.WriteLine("The city for ZIP code {0} is {1}",

addr.ZipCode, addr.City); }

}


Tulajdonságok IL-ben


Példa - indexer

using System.Collections; class MyListBox{ protected ArrayList data = new ArrayList(); public object this[int idx] { get{ if (idx > -1 && idx < data.Count){ return (data[idx]); }else{ throw new InvalidOperationException("[MyListBox.set_Item]” +

"Index out of range"); }} set{

if (idx > -1 && idx < data.Count){ data[idx] = value; } else if (idx == data.Count){ data.Add(value); }else{

throw new InvalidOperationException( "[MyListBox.get_Item] Index out of range");

} }}}


Példa – indexer teszt

class IndexersApp{

public static void Main(){

MyListBox lbx = new MyListBox();

lbx[0] = "foo";

lbx[1] = "bar";

lbx[2] = "baz";

Console.WriteLine("{0} {1} {2}", lbx[0], lbx[1], lbx[2]);

}

}


Osztály részei

Adattagok (Field) - adatok Konstansok (Constant) - állandó adatok Csak olvasható mezők (read only)

Tagfüggvények (Method) - fv.-ek Operátorok (Operator) - speciális tfv.-ek Indexelők (Indexer) - speciális tfv.-ek

Tulajdonságok (Property) - kivülről adat, belülről fv. Delegátumok - típusos fv.pointerek (külön diasorozat) Események (Event) - delegátumok (külön diasorozat)

Documents

C# osztályok