Programozás alapjai

Programozási alapfogalmak

Paradigma: Felfogásmód, gondolkodásmód, szemlélet, látásmód, megoldási technikák.

Strukturált program:

Egyetlen absztrakt utasítás. Felbontjuk elemibb utasítások sorozatára. Felbontás addig, míg a gép által érthető lesz.

Procedurális, vagy moduláris programozási paradigma:
– A procedurális főprogramot részekre, modulokra (packages, units) bontjuk.
– Minden modul egy vagy több alprogramra oszlik, melyek eljárásokból, függvényekből szubrutinokból
állnak. Az alprogramok további alprogramokat tartalmaznak.
– Minden hatókör tartalmaz olyan neveket, melyeket rajta kívül nem láthatunk.

Objektumorientált program: Adatok és műveletek egy egységben. Feladat: az önálló felelősséggel bíró egységek meghatározása, a közöttük fennálló kapcsolatok meghatározása.

Objektumorientált programozási paradigmák
– Objektumok: Egy egységben az adatok és a rajtuk végzett műveletek. Egyszerre a modularitás és a
struktúra elemei.
– Absztrakció: Gondolkozhatunk a rendszer elemeiről, mit ‘aktorokról’ melyek végrehajtják a feladatokat, megváltoztatják állapotukat, kommunikálnak más objektumokkal, anélkül, hogy ismernénk az implementációs részleteket.
– Egységbezárás, vagy az információ elrejtése: Az objektumokat nem lehet kívülről nem várt módon manipulálni. Csak meghatározott metódusokon keresztül módosítható az állapot.
– Polimorfizmus: A referenciák különböző típusú objektumokra hivatkozhatnak, és a hivatkozott objektumoktól függő viselkedést produkálhatnak.
– Öröklés: Létrehozhatók már létező típusok specializációi, melyek használhatják (és bővíthetik) a létező típusok műveleteit anélkül, hogy újra meg kellene valósítani őket.

Program komponens:
– A kód egy fizikailag elkülönített, a telepítés során önálló egységet képező (lefordított) része.
– A komponens jellemzően több osztályt tartalmaz.
– Komponensek pl. az exe és dll állományok.
Osztály, objektum
– Az osztály egy típus megvalósítása.
– Az objektum az osztály egy példánya, előfordulása.
– Az osztály tartalmazza a adattagok típusainak leírását, amely alapján a konstruktor az objektum számára a helyfoglalást végzi.
– Az osztály tartalmazza a metódusok kódját. A metódusokat objektumokra hívjuk meg, és az objektumban tárolt adatokon dolgoznak. (Kivétel statikus metódusok, lásd később.)
– Az osztály tartalmazhat további osztály leírásokat. Ezeket beágyazott osztályoknak (nested class) hívjuk.

Példányosítás:
– Egy osztálynak akárhány példánya, objektuma lehet.
– Az objektumok a memóriában más-más területen helyezkednek el.
– Az objektum adattagjainak a futás során változik az értéke, változik az objektum állapota.
– Egy adott pillanatban több objektum adatai is megegyezhetnek, ilyenkor az objektumok állapota megegyezik.

Függvény átdefiniálás: ( Overloading, túlterhelés)
– A függvény azonosítása a szignatúrája (neve és paraméterlistája) alapján történik.
– A paraméterlistában a paraméterek típusa és sorrendje rögzített. Nevük nem egyezhet meg a tagváltozók nevével! (Hisz azonos szinten érhetők el.)
– Több azonos nevű, de eltérő paraméterlistájú függvényt hozhatunk létre.
– A fordító számára híváskor egyértelműnek kell lennie melyiket hívjuk.

Alapértelmezett paraméterek:
– A paramétereknek alapértelmezett kezdőértéket adhatunk.
– Lehetővé teszi, hogy híváskor az adott paraméter megadást elhagyhassuk.
– Előnye:

• Sok paraméter értéke többnyire egy szokásos érték. Nem kell kiírni, sőt tudni sem.
• A különböző paraméterszámú átdefiniált függvényeket egy függvénnyel adhatjuk meg.

– Alapértelmezés jobbról balra halad
– A paraméterlista sorrendje, típusa kötelező.
– A nem alapértelmezett paraméterek az elsők.
– A leggyakrabban változó paramétereket adjuk meg elöl, a többnyire alapértelmezett paramétert a végén.

Konstruktor
A konstruktor az osztály egy speciális tagfüggvénye.
– Feladata: az objektumok létrehozása, inicializálása. Később további feladatok.
– Neve általában megegyezik az osztály nevével.
– Visszatérési értéke nincs.

Destruktor
– A destruktor az osztály egy speciális tagfüggvénye.
– Feladata: az objektumok felszámolása.
– Visszatérési értéke nincs.

Egységbezárás (Encapsulation)
– Az adatokat és a rajtuk végzett műveleteket egységbe zárja. Ez az egység az osztály.
– Az osztály egy típus megvalósítása, mely magába foglalja a típus adattagjait (tagváltozóit), és a rajtuk
végezhető műveleteket (tagfüggvények, metódusok).
– A láthatóságok vagy hozzáférési szintek (visibility, accessibility) tovább bővítik az egységbezárás
lehetőségeit. Segítségükkel megvalósítható az ellenőrzött adatbevitel, adatolvasás.
– Az egységbe zárás lehetővé teszi, hogy az osztály adattárolása módosítható legyen, anélkül, hogy az őt
használó osztályok kódját módosítanunk kellene.

Property (tulajdonság) :
– A tulajdonság (nagybetűvel) a hívó kódban úgy viselkedik mint egy
tagváltozó, de értékadáskor a set metódusa hívódik, míg olvasáskor a
get metóduson keresztül jutunk az adathoz.
– A tulajdonság segítségével gyakran egy adattag egy részét, vagy több
elrejtett adattagban tárolt adatot kezelünk.
– Saját készítésű vezérlő esetén a tulajdonság megjelenik a Properties
ablakban, kezdőértéke a fejlesztés során kényelmesen állítható be.

Struktúra (struct):

Főként különböző típusú adatok tárolására használják, de tagfüggvénye is lehet.

Interfész (interface):

Nem tartalmaz adattagokat, és nem példányosítható. Alapértelmezett láthatóságuk is eltérő.

this vagy Self
– A metódusok kódja az osztályleírásban tárolódik.
– A metódusok az objektum adatain dolgoznak.
– A this az aktuális objektumra mutat, ill. hivatkozik.
– Ha egy másik objektum tagfüggvényének át akarjuk adni a hívó objektumot paraméterként, a this-t használjuk.
– A futásidejű típusinformáció lekérdezésére.

JS programozási fogások

Okosítása az új függvénnyel és bővített funkcionalitás használata:

//-- deff :
Array.prototype.remove = function() {
 var mit, a = arguments, hossz = a.length, ax;
 while (hossz && this.length) {
 mit = a[--hossz];
 while ((ax = this.indexOf(mit)) !== -1) {
 this.splice(ax, 1);
 }
 }
 return this;
};

//-- használat:
var tombom = ['szov1', 'szov2', 'szov3', 'szov4'];

tombom.remove('szov2');
console.log(tombom);

/* Eredmény Log : ["szov1", "szov3", "szov4", remove: function] */

 A felül deffinálásnál az objektum használatokat ellenőrizni kell, hogy az új tulajdonság nem borítja fel az eddigi működést, hibakezelés, … teszt is szükséges lehet.

Önálló globális függvény paraméteres meghívással:

//-- deff:
function removeGlobal(tomb) {
var mit, a = arguments, hossz = a.length, ax;
while (hossz > 1 && tomb.length) {
mit = a[--hossz];
while ((ax= tomb.indexOf(mit)) !== -1) {
tomb.splice(ax, 1);
}
}
return tomb;
}

//-- Használat:
var tombom = ['szov1', 'szov2', 'szov3','szov4'];
removeGlobal(tombom, 'szov2');
removeGlobal(tombom, 'szov3');
console.log(tombom);