Mit javasoltok?

Mivel még csak most kezdenéd el a programozást, így még most eltekintek tőle, de kezdd azzal, hogy beírod a keresőbe, hogy "C# tutorial". Óh, és igen, a programozás nyelve az angol, ezért adtam neked angol keresőkifejezést.

Nézd el nekem, hogy játékfejlesztés fejé hajlik a dolog, de itt mindenki Crysis 26-ot akar írni.

Szépen sorjában így lenne illő haladnod:

- Mi az a programozás, mire jó, miért jöttek létre a számítógépek?

- Tanulsz egy kis algoritmizálást, hogy pszeudokódban hogyan lehet megírni egyszerűbb programokat, megtanulsz egy-két vezérlési szerkezetet (ez ahhoz kell, hogy segítse a programozói gondolkodás kialakulását)

- Elsajátítod az egyszerűbb adatszerkezetek elvi működését (tömb, láncolt lista, verem, sor, hash tábla stb.)

- Választasz egy programozási nyelvet, mondjuk kezdésnek a Pythont szokták ajánlani a leggyakrabban. No, én azért ajánlom ezt a nyelvet neked, mert rákényszerít, hogy olvasható, jól tagolt kódot írj.

- Hello World

- Kifejezések, utasítások

- Változók

- Egyszerű beolvasás konzolról

- Vezérlési szerkezetek

- Előre megírt függvények használata

Most tartunk ott, hogy meg tudsz írni egy "gondoltam egy számot, találd ki" játékot

- Függvények, eljárások írása

- Karakter/stringkezelés

- Fájlkezelés (szöveges és bináris)

Már meg tudsz írni egy Legyen Ön is Milliomost konzolosan

- Új programnyelv választása, ha olyat választottál először, ami nem tud OOP-t. Itt már erősen ajánlom a C#-pot, mert kezdők könnyen tudnak vele ablakos progikat készíteni mindenféle segédeszköz (pl. Qt) nélkül. [Java téren a Swing-et próbáltam eddig, és hát meg is van a véleményem róla...]

- OOP alapelvek megismerése

- Eseményvezérelt programozás, egyszerű ablakos szoftverek készítése

- XML, JSON állományok létrehozása és feldolgozása

- Egy RDBMS rendszer megismerése (pl. MySQL, Microsoft SQL Server, Oracle...)

- Több szálon futó programok, párhuzamosítás

- Hálózati alapismeretek elsajátítása, főleg TCP és UDP

- Hálózaton kommunikáló programok írása

Már mehet a felhasználóbarát ablakos kvízjáték hálózaton multiplayerben

- Matematikai ismeretek elsajátítása, vektorok, mátrixok, koordinátageometria, koordinátatranszformációk mátrixokkal

- Számítógépi grafikai ismeretek, hogyan rajzol ki a gép egy pontot, vonalat, görbét, Window to Viewport transzformáció, 3D-s objektum leképezése 2D síkra, stb.

- DirectX vagy OpenGL közül választasz egyet

- Megpróbálod alkalmazni a grafikai ismereteidet

- Felhasználói interakció kezelése

- Textúrázás

És, már mehet a már immáron grafikus kártyát kihasználó multiplayer Pong vagy valami platformjáték

- Egyszerűbb 3D-s objektumok rajzolása, animálása

- Összetettebb 3D-s világ létrehozása

- Megpróbálsz megírni egy egyszerűbb grafikus motort (hogy lásd a lelki világát mondjuk a CryEngine-nek)

És már meg tudsz írni elméletben egy WoW-ot (csak épp egyedül kevés vagy hozzá).

Ha a játékban ellenséget is akarsz magadnak, akkor ismerkedj meg a mesterséges intelligencia alapjaival, hogy hogyan írunk le egy problémát (állapottér-reprezentáció), hogy milyen algoritmusok segítségével lehet utat találni a kezdetektől a célállapotig (erre jók a megoldáskeresők, pl. próba-hiba, hegymászó algoritmus, backtrack algoritmusok, ág és korlát, A, stb.), és ismerkedj meg a lépésajánló algoritmusokkal (minimax, negamax), amik egy adott állapotra meghatározzák a létező legjobb lépést.

====================================================

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. 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ó.

"Egy harmadéves DE-IK PTI hallgató."

Szövegértést javaslom első lépésnek.