C#-ban nemértem ezt az egész metódus dolgot. Elmagyarázná valaki?

Ez úgy egy 45 perces óra anyaga. Ugye nem gondoltad, hogy majd valaki itt leírja neked?

Javaslom rágd át magad még egyszer ezen az anyagrészen, mert ebből látszólag nem sokat értettél meg.

1.Static után a kimeneti vagy a bemeneti érték típusa kell?

Visszatérési érték típusa.

2.Metódusneve utáni zárójelben mi szokott lenni?

Paraméterek. "Típus Név" formátumban.

3.Mi az az "args"?

Parancssori argumentumokat tartalmazó string tömb.

4.Ha a return utáni változó a kimeneti érték, mire kell figyelni akkor ha azt akarom hogy tömböt adjon vissza a metódus?

Hogy tömböt adj vissza.

5. Mi a get és a set?

Tuladonságokhoz tartozó lekérdező, beállító kulcsszavak.

Remélem most boldogabb lettél.

Metódus gyorstalpaló:

int Osszead(int a, int b) { // Két számot összeadja

return a + b;

}

Ahogy látod, metódus neve előtt annak visszatérési értéke látható, neve után (zárójelben) pedig a paraméterei. Innen ered az általad emlegetett "par1" és "par2", amely a paraméterek neve, és ekként tudsz rájuk hivatkozni a függvény törzsén belül.

private/public (még van pár, de jelenlegi szinteden ezek a legfontosabbak): ezek adott függvény (vagy éppen tagváltozó) láthatóságát definiálják. Egy public metódust bárhonnan (más osztályból) is meg lehet hívni, private-et viszont csak adott osztályból.

static nem kötelező, csak az osztályszintű metódusokat/változókat jelölik így. Persze ahogy látom, ti egyelőre nem foglalkoztatok az objektum orientáltsággal, így valóban olybá tűnhet, mintha "kötelező" lenne.

Végezetül ajánlom ezt az (ingyenes) könyvet: [link]

Egyrészt örülök, hogy megértetted...

Ugyanakkor a hozzáállás az szerintem nem a legjobb. Nem ismered a választ, de tudod, hogy annak milyen hosszúnak kell lennie. Nincs itt valami ellentmondás?

A függvények használatát nekünk, hasamra ütöttem és írtam hogy, egy 45 perces órán tanították, nem tudom, lehet hogy kétszer 45 volt. Viszont abban biztos lehetsz, hogy ez a téma lényegesen nagyobb annál, mint hogy 10 percben el lehessen mondani.

Ha elég lenne rá 10 perc, akkor egy nyelv megtanulása meddig tartana? 2 óra?

Ne legyen igazam, de mernék rá fogadni, hogy amit most megértésnek gondolsz, az úgy két lépéssel van a "mert úgy kell és kész" választól és mérföldekre az "így működik a függvény hívás..." kezdetű választól.

Persze ha neked elég, akkor az csak neked jó.

Már egy jó párszor leírtam, de bemásolom neked, hogy tisztán lásd ezt az egészet.

Szóval az OOP-ról érthetően és magyarul:

Ha szétnézel magad körül, látni fogsz jó néhány tárgyat. Pl. asztal, ablak, lámpa, szék, csak hogy párat említsek. Hogyan kezdődött ezeknek a tárgyaknak az élete? Leültek és megtervezték. Készítettek egy tervet arról, hogy milyen tulajdonságokkal kell rendelkeznie az adott tárgynak. Az asztal esetében ilyen tulajdonság lehet az, hogy hány lába van, milyen anyagból készült, milyen színű, mekkora a mérete. A tervben azt is leírják, hogy az adott tárgynak milyen cselekvései vannak, és hogyan végzi ezeket a cselekvéseket. Nyilván egy asztal nem tud túl sok mindent csinálni, viszont ha nézünk egy lámpát, az például tud világítani, és az is leírható, hogy hogyan végzi ezt a világítás tevékenységet. Ez mind szép és jó, de ugye egy tervben, papíron létező asztal vagy lámpa még nem létezik, le kell gyártani azt. A gyártás után kapjuk meg a kézzel fogható példányt. A gyártás során dől el az is, hogy az egyes kész termékek tulajdonságai milyen értékeket vesznek fel. Ugyanis lehet gyártani például üvegből készült, átlátszó színű asztalt, de lehet fából készült, barna színű asztalt is.

Eme rövidke példa után nézzük, hogy ennek mégis mi köze volt a programozáshoz.

Mikor egy programot az OOP paradigma szerint készítünk el, ugyanez történik, mint velünk a való életben. Magát a programot fel lehet fogni egy világként. Ahhoz, hogy ebben a világban legyen nekünk valami, terveket kell készíteni, hasonlóan, ahogy mi is megterveztük az asztalt. Egy-egy ilyen tervet hívunk OSZTÁLYnak. A tervben (vagyis osztályban) leírt tulajdonságokat hívjuk MEZŐnek, ami nagyjából ugyanaz, mint egy hagyományos változó. Továbbá, az osztályban leírt cselekvéseket hívjuk METÓDUSnak, ez kvázi a hagyományos értelemben vett függvény vagy eljárás. Ahhoz, hogy a programunk világában ezekből a tervekből, osztályokból "kézzel fogható" tárgy legyen, PÉLDÁNYOSÍTANI kell. Ez az a gyártási folyamat, amelynek során megkapjuk a már használható és létező OBJEKTUMot (más néven PÉLDÁNY). Így első körben azt gondolná az ember, hogy minden, amit az osztályban leírunk, a példányokra is érvényes lesz. Akkor jöjjön az érvágás: ez nem éppen így van. Ugyanis vannak PÉLDÁNYSZINTŰ tagok az osztályban (tag = bármi, ami az osztályban le van írva), amik a példányokra vonatkoznak, és vannak OSZTÁLYSZINTŰ tagok, amik magára az osztályra jellemzőek. Furcsa, de az OOP paradigmában egy "papíron létező" terv is végezhet cselekvéseket, és lehetnek tulajdonságai. Ennek általában akkor van szerepe, amikor nem egy-egy konkrét példányra, hanem általánosságban a példányokról tudunk információt szerezni, műveletet végezni. Erre egy egyszerű példa:

A fájlrendszerben léteznek könyvtárak. Egy-egy könyvtárnak legyen példányszintű tulajdonsága a benne lévő fájlok száma, azok összegzett mérete. Például a C:\valami könyvtárra jellemző, hogy van benne 3 fájl azok mérete összesen 20KiB, vagy C:\másvalami 8 fájllal és 2GiB mérettel. Ezek létező példányok. Ugyanakkor, ami az osztályt magát jellemezheti, hogy hány könyvtár van a fájlrendszerben, és le tudsz kérni egy listát a könyvtárakról. Ez természetesen egyik példányra sem vonatkozik, ezért lesz osztályszintű tag.

Az ilyen osztályszintű tagokat szokás STATIKUS TAGnak is nevezni, és a legtöbb programnyelv a static kulcsszóval jelöli. Nézzük meg, hogyan is történik a példányosítás. A példányosítás során a gyártó elkészíti a kész terméket. Az OOP-ben ezt a gyártót nevezzük KONSTRUKTORnak. Így első hallásra elég durvának tűnhet, de csupán arról van szó, hogy a memóriában lefoglal annyi területet, amiben a példányszintű tagok elférnek, továbbá itt szokás kezdőértéket is adni az osztály mezőinek. Ez a konstruktor egy olyan speciális metódus, ami akkor hívódik meg, amikor mi példányosítjuk az osztályunkat. Néhány programozási nyelv, többek közt a Java és a C# is eljárásként kezeli ezeket, olyannyira, hogy a visszatérési érték típusát is tilos kitenni a konstruktormetódus neve elé. Általában a konstruktornak kitüntetett neve van. C#-pban, C++-ban és Java-ban az osztály nevével egyezik meg, PHP-ban __construct névre hallgat.

Az OOP azért jött létre tehát, hogy a mi világunkat modellezzük benne. Ez azért lesz jó, mert jól elkülöníthető részekre osztja fel a mi kódunkat, sokkal jobban áttekinthető az EGYSÉGBEZÁRÁS ELVE miatt. Ez nemes egyszerűséggel annyit takar, hogy a lámpára vonatkozó cselekvéseket nem keverjük össze még kódlogikailag sem az asztal metódusaival és adattagjaival. Ez az összevisszaság leginkább az eljárásközpontú nyelvekben vehető észre, például a C-ben. Bár külön-külön fájlokra oszthatjuk fel a kódunkat, mégsem különülnek el az egyes dolgokra vonatkozó alprogramok. Az egységbezárás elve miatt rögtön jön egy fontos tulajdonság, a LÁTHATÓSÁG. Ennek csupán annyi a feladata, hogy az osztály és a példány tagjait a külvilág elérheti-e. Elvégre elég hülye tervezés lenne, ha például az ember irányíthatná a szívét, vagy beleszólhatnék az autó belső működésébe.

Ember e = new Ember();

e.Szívritmus = 0; //Halott ember vagyok - ezt nem lenne szabad megtennem

Az ilyen esetek elkerülésére az osztály és a példány tagjait LÁTHATÓSÁGI MÓDOSÍTÓval láthatom el. Az OOP paradigma 3 láthatóságot szab meg:

- a külvilág számára elérhető tagok, azaz NYILVÁNOS, PUBLIC

- a külvilág számára nem, de az osztályon/példányon belülről látható tagok, azaz REJTETT, PRIVATE

- a külvilág számára nem, de az osztályon/példányon belülről, valamint az osztályból származó további osztályok számára elérhető, azaz VÉDETT, PROTECTED

Feljött egy fontos definíció, a származtatás, ÖRÖKLŐDÉS. Ez arra lesz jó, hogy én már megírtam, hogyan kell működnie egy lámpának. De én ezt tovább akarom fejleszteni, létre akarok hozni asztali lámpát és csillárt is. Azért lesz ez nekem jó, mert már én egyszer megírtam, hogy mit kell tudnia egy lámpának - és ezt már nem kell többször megírnom, elég csak azt mondanom, hogy a lámpában szereplő tagok alapján létre akarok hozni egy új osztályt. Ilyenkor kvázi "átmásolódnak" a lámpa osztályból a tagok az asztali lámpa osztályba, ugyanakkor én ebből semmit sem látok, csupán ennyit:

class Lampa {

public int Teljesitmeny;

public int IzzokSzama;

public void Vilagit() {

Console.WriteLine("Világít a lámpa");

}

}

class AsztaliLampa : Lampa {

}

Így bevezetőnek ennyit, ehhez még rengeteg definíció tartozik, például helyettesíthetőség, mi az az aktuális példány (this/self), getter/setter metódusok, referencia- és értéktípusok, és még sorolhatnám...

Egy harmadéves DE-IK PTI hallgató.

After the lecture a man reached for a woman's breast.

Woman: Hey! It's private OK!?

The man hesitated for a second looking confused.

Man: But I thought we were in the same class?