Mit jelent az, hogy OOP? Objektumorientált programozás?

Nem lehet úgy leírni mintha egy 5 éves gyereknek magyaráznád, mert bonyolultabb mint amit egy 5 éves érdemben fel tud fogni - beszélni kéne az osztályokról, típusokról, öröklésről, és így tovább, néhány mondatban nem lehet összefoglalni úgy, hogy bármiféle előismeret nélkül megértsd. A wikin értelmesen le van írva(bár sok a felesleges töltelék)

[link]

[link]

Az 5 éves verzió, procedurális megközelítésben:

változó Cica_pozíció = 0

function Cica_szaladj() {... Cica_pozíció++; ...}

Cica_szaladj()

OOP, a teljesség bármilyen igénye nélkül:

osztály Cica

__pozíció = 0

__metódus Szaladj() {... saját pozíció++; ...}

új Cica1

Cica1.Szaladj()

új Cica2

Cica2.Szaladj()

stb.

:))

Talán nagyon nagy vonalakban így mondható el:

Az programozásbeli objektumok hasonlítanak a valóságbeli objektumokra. Mindegyiknek van tulajdonsága, vannak hasonlók is egymás között és vannak olyanok, amelyek más objektumokat is tartalmaznak (pl egy autó tartalmaz sebváltótól kezde anyámkínjáig mindent, ezek külön objektumok). Egyes objektumokkal lehet műveleteket is végezni (pl kalapács).

A programozásban minden objektumnak van egy alapterve, vagy úgy is nevezhetnénk, ideálja (ez az osztály). Ebből fog származni az objektum, vagy objektumok. Mert egy osztályból több objektum is származhat.

Az osztály tulajdonságai a tagváltozók. Ez bármi IS lehet. Valóságbeli példa, például egy asztal, aminek van magassága, színe, anyaga, lába(i) (ez utóbbiból lehet több, tehát programozásban ez egy összetett adattag, tömb akár, vagy egy másik objektum).

Az osztály metódusai/tagfüggvényei pedig tulajdonképpen az objektummal elvégezhető műveleteket írják le. Pl egy kalapács esetén az üss() lehetne egy függvény. Vannak olyan függvények, amelyek visszaadnak valamilyen értéket (pl. egy hámozógépbe bekerül egy alma, és abból kijön a meghámozott alma), és vannak olyanok, amelyek csak csinálnak valamit (például egy ecset osztály fess függvénye valamit átfest, vagy megrajzol).

Visszatérve az elejére, azért mondtam, hogy az osztály az objektumok ideálja, mert amíg az osztály csak leírni hivatott valamit, addig az objektumok valós dolgokat tárolnak. Képzelj el például egy Kutya osztályt. A kutyának lehet fajtája, színe, magassága, lábszáma (sérült kutyák esetén kevesebb), neve, stb. Amikor létrehozol egy objektumot ebből (származtatod), akkor ott meg kell adnod a kutyád konkrét tulajdonságait.

Tehát van egy Rottweilered ami a Kutya osztályba tartozik. És van egy keverékebed, ami úgyszintén a Kutya osztályba tartozik. DE! A Rottweiler magassága 60cm, neve például Bátor. Színe jellegzetesen fekete, de lehet egyedi objektumként is felfogni, amivel kialakítasz tarka színt. A kotorékebed pedig 30cm magas, neve Gyáva és barna színű.

A programozásban ez így valahogy néz ez ki:

// Kutya osztály implementálása

class Kutya {

string Nev {get;set;}

Color Szin {get;set;}

string Fajta {get;set;}

.

.

.

}

// Rottweiler objektum létrehozása

Kutya rottweiler = new Kutya();

rottweiler.Nev = "Bátor";

rottweiler.Szin = new Color(255,255,255);

rottweiler.Fajta = "Rottweiler"; (Bár ilyesmit tiszta kód szempontjából nem szokás csinálni, példának megfelel)

// Keverékeb objektum létrehozása

Kutya keverek = new Kutya();

... // és így tovább

Na most. A kutyák tudnak dolgokat csinálni is. Például járni, futni, ugrani, stb. Ezeket a függvényeket is a Kutya osztályban definiálod, de az objektumon hívod meg őket:

class Kutya {

...

public void Ugat()

{

Console.WriteLine("Vau-vau");

}

public void Ugrik()

{

Console.WriteLine("[UGRÁS]");

// komplexebb logika folytatódik...

}

public void Harap(Ember kit)

{

// HARAP DEFINIÁLÁSA

}

public string GetName()

{

return Nev;

}

}

és amikor használod:

rottweiler.Ugat();

rottweiler.Ugrik();

keverek.Ugat();

keverek.Harap(postas);

string kutyaNeve = keverek.GetName();

És akkor most nagyvonalakban az öröklésről:

Az osztályok örökölhetnek egymástól. Ez azt jelenti, hogy az örökös megkapja MINDEN tulajdonságát és tagfüggvényét annak az osztálynak akitől örököl (itt fontos megjegyezni a láthatóságot, de ennek nézz utána magad, ne mindent én írjak le :D).

Az előbbiekhez visszakanyarodva a Rottweiler legyen most egy osztály, mintsem objektum:

class Kutya {

string nev {get;set;}

...

}

class Rottweiler : Kutya // kutyától örököl, minden tulajdonságát megkapja annak

{

// itt csak az egyedi tulajdonságokat és metódusokat kell definiálni

Foltok foltok {get;set;} // A Foltok egy másik osztály, ami leírja, hogy az objektumnak lehetnek foltjai, ezt te definiálod, hogy mi módon hajtódjon az végre.

}

Osztályok lehetnek abstract-ak. Ez annyit tesz, hogy néhány függvényt megírunk az ősosztályban, de ha ez nekünk nem tetszik egy gyerekosztályban, akkor azt felülírhatjuk ott.

Oszátlynak lehetnek interface-ei. Na ez pedig inkább a tiszta kódban használandó és ajánlott is. Itt nem írunk semmi konkrét dolgot, csak azt, hogy az a valami hogy fog kinézni. Például van a postás bácsi. Ő egy Alkalmazott interface-t implementál, de egyúttal az Ember interface-t is. A végeredmény az lesz, hogy minden az Alkalmazott és Ember interfaceben leírt függvényt meg kell valósítanod a Postas osztályban.

Na hát "röviden" ennyi, lehetne még írni róla regényeket, de szerintem a kezdőlökést megadtam. :)

#5-ös: újoncok mindig is voltak, vannak és lesznek. Sajnos minden újszülöttnek meg kell tanítani, hogy a google igenis jó dolog, és lehet használni is. Reménykedem benne, hogy előbb-utóbb úgy születik mindenki, hogy tudja használni a keresőt, de szerintem még nem jött el az az idő.

Gondolkodtam már rajta, hogy létrehozok egy oldalt, ahol részletesen leírom (magyarul-angolul), hogy hogyan kell használni a googlet egy kezdő programozó számára, de egyelőre nem jutott időm kivitelezni ezt.