Változók a programozásban

Változók a programozásban

Ebben a témában: Alapok, C Programozas, Java Programozas

Vannak a programozásban általánosan használt eszközök, fogalmak, amik minden programozási nyelvben megjelennek. Most a Változókról és azok használatáról szeretnék egy kicsit beszélni és egy konkrét példán keresztül megnézni, hogy miért is van szükség változókra és hogyan is működnek pontosan.

 

Mik azok a Változók?

Egy programban adatokkal dolgozunk. Legtöbbször ezekre az adatokra nem csak egyszer van szükségünk a programunkon belül (például arra, hogy kiírjuk a képernyőre a felhasználónak), hanem további műveleteket, feladatokat szeretnénk velük végezni. Annak érdekében, hogy ezek az adatok a programunkon belül több helyen is elérhetőek legyenek, el kell azokat tárolnunk valahol, hogy később használhassuk őket. Az adatokat pedig a Változókba tudjuk eltárolni.

Úgy is megfogalmazhatjuk, hogy egy Változó olyan, mint egy Doboz. Bele tudunk tenni valamilyen értéket ebbe a dobozba és ha valamikor később szükségünk lesz rá, akkor csak kinyitjuk a dobozt és kiolvassuk belőle. Ezen felül még extra tulajdonság, hogy a dobozba (vagyis a változóba) bármikor új adatot is tudunk tenni. Ilyenkor vigyázni kell, mert a régi adat törlődik belőle, felülíródik az új adattal.

 

Változók típusai

Az előbb tárgyalt mechanizmus már csak annyiban fog bonyolódni, hogy minden Változónak meg kell adnunk egy típust is. Ez a típus fogja meghatározni, hogy milyen fajta adatot lesz képes tárolni a Változónk. A típusokat alapvetően két nagy csoportra oszthatjuk: Szám és Szöveg típusok. A szám típusú változók csak számokat, míg a szöveg típusú változók csak szövegeket képesek tárolni. Ha pedig egyszer definiáltuk a változónk típusát, akkor azt később már nem tudjuk megváltoztatni (a legtöbb programozási nyelvben).

Nézzünk meg egy-egy példát Java nyelvből:

Típus neve

Formátum

Példa

String

szöveg

“Hello World”

int

egész szám

12

 

 

Miért van erre szükség?

Felmerülhet, hogy miért kell adatokat eltárolnunk egy programon belül egy változóba? Hiszen láttuk az első programunkban, hogy képesek vagyunk kiíratni az adatokat a képernyőre, akkor meg minek ezt tovább bonyolítani?

Egy program célja legtöbbször nem csak annyi, hogy csak megjelenítjük az információkat a képernyőn és kész. Ettől jóval többről van szó és ez miatt nem csak egy adott pillanatban van szükség az információra, hanem később is, amikor valamilyen összetett logikát valósítok meg. A változók használata tehát nagyon fontos része a programoknak.

 

 

Technikai megvalósítás

Az elméleti rész elsajátítása után nézzük meg, hogy hogyan kell használni a változókat a gyakorlatban.

(more…)

Hogyan zajlik egy Szoftverfejlesztői Állásinterjú?

Ebben a témában: Alapok

Ha szóba kerül az Állásinterjú, akkor szerintem kicsit mindenki feszült lesz, köztük én is. Nem egyszerű helyzet ez, én sosem tudtam megszokni. Új környezet, új emberek, mindenki a legjobbat szeretné megmutatni magából. Sajnos azonban ez egy szükséges lépés, ha szeretnénk munkát, ezért talán érdemes lenne röviden áttekinteni egy szoftverfejlesztői interjú tipikus lépéseit.
Ezek a beszámolók a saját tapasztalataimon alapulnak, nem biztos, hogy a te interjúd is pontosan így fog majd zajlani.

 

 

Az Állásinterjúk valahol ott kezdődnek, hogy elkezdjük otthon a nappaliban megírni az önéletrajzunkat (CV). Már itt érdemes a precizitásra törekedni, nem ajánlom, hogy valaki a szakmai részen nagyot ferdítsen, de erről kicsit később. A formátumot érdemes kölcsönkérni ismerőstől vagy lenézni a netről, a saját formátumot nem ajánlom. Amire felhívnám a figyelmet, hogy a kis profilképnek igyekezzünk ne olyat választani ami a 3. pálinka után készült a barátokkal, hanem egy sima, egyszerű, fehér fal előtt készült mosolygós képet, ahol tisztán látszik az ember arca. Sajnos ez nem mindenkinek evidens…

 

Ezután átböngésszük a nyitott pozíciókat, majd elküldjük a CV-nket.
Valószínűleg 1-2 napon belül fogunk kapni egy telefont egy kedves kapcsolattartótól, hogy mikor lenne az első interjú időpontja. Ekkor azonban már történhet egy nagyon rövid, de nem szakmai beszélgetés is, akár angolul is! Érdemes elfogadni az első időpontot, amit felajánlanak, de mindenképpen lebeszélni egy időpontot. Ha úgy rakjuk le a telefont, hogy nincs konkrét időpont vagy később lemondjuk, akkor ettől a helytől 90%-os valószínűséggel el is búcsúzhatunk, úgyhogy erre mindenképpen figyeljünk oda!

 

Egy állásinterjúra mindig percre pontosan érkezzünk! Erre azért van szükség, mert velünk ellentétben az interjúztatónak van munkája, tehát elfoglalt.
Én mindig úgy szerveztem a napom, hogy mondjuk 30 perccel előbb odaérjek. Ebbe belefér akkor egy kis csúszás, lerobban a villamos, dugó, stb… legrosszabb esetben sétálgatok 30 percet az épület előtt. Nem kell túlöltözni, de egy farmer – ing kombináció nem árt.

 

A beszélgetés eleje általában bemelegítő jellegű, semmi veszélyes, Jónapot – Jónapot, Hogy van ma? Az állásinterjúk legelső felében általában röviden beszélünk a cégről, mint munkahely. Érdemes egy 10 percet rászánni otthoni felkészülésre, mi az adott cég neve, mi a profilja, milyen állásra jelentkeztünk, egy-két alapdolog.

Ezután kezdődnek az izgalmasabb részek, amikor elkezdünk végigmenni a beadott önéletrajzon. Itt nem felolvasásra kell gondolni, hanem általában megkérik a jelentkezőt, hogy meséljen az önéletrajzának egyes pontjairól.

(more…)
Java és C Függvények

Függvények Használata

Ebben a témában: Alapok, C Programozas, Java Programozas

Többször beszéltem már a függvények használatának fontosságáról (többek között Programok működésének felépítése és Függvény és Változó nevek). De még nem beszéltem arról, hogy pontosan, hogyan is kell létrehozni illetve használni a függvényeket. Ez az egyik alapvető része a programozásnak, ezért következzen most egy rövid gyakorlati bemutatás.

 

Ez a bemutató érvényes mind a Java, mind pedig a C nyelvre, minthogy a függvények használata mind a két nyelvben ugyanúgy történik, de én most mégis egy rövid Java programban fogom végigvenni a lényeget.

 

Mielőtt rátérnék a gyakorlati részre, gyorsan nézzük meg, hogy elméletben mit is jelent egy függvény a programozásban?
Egy függvény nem más mint egy végrehajtható kódhalmaz, ami mindig ugyanazt csinálja, éppen attól függően, hogy milyen céllal hozták létre az adott függvényt. Tekintsünk a függvényre úgy mint egy fekete doboz, nem kell feltétlen ismernünk a tartalmát, van valamilyen bemenete és abból valamilyen módon előállítja a kimenetét. Ezt a dobozt (a függvényt) bárhonnan fel lehet használni, meg lehet hívni. Egy ilyen függvényhívás során, a függvényben lévő kódhalmaz végrehajtódik. A függvények célja nem más, mint a program egyes részeinek feldarabolása. Mintha egy könyv tartalmát fejezetekbe osztanánk fel, úgy osztjuk fel a programot különböző függvényekbe. Illetve mivel egy függvényt többször is meghívhatunk, ezért a program egy fontos részegységét elég egyszer lekódolni és azt utána tetszőlegesen sokszor felhasználhatjuk. Minden függvényhívás során ugyanaz a kód fog végrehajtódni, függetlenül attól, hogy a függvényt honnan hívták. Attól, hogy a függvény végrehajtása befejeződött, attól még maga program nem ér véget, hanem onnan folytatódik tovább ahonnan a függvény meg lett hívva. Két fontos lépés van:

  1. A függvényhívás helye
  2. A függvény tartalma

 

Először is nézzük meg, hogy hogyan lehet létrehozni egy függvényt. Minden függvénynek három része van:

  1. A függvény visszatérési értéke -> A függvény által kiszámolt érték
  2. A függvény neve
  3. A függvény bemenete -> Azok a bemeneti adatok, amiket minden függvényhívás során kötelezően meg kell adni

(A dolog kicsit tud bonyolódni, ugyanis nem biztos, hogy egy függvénynek van visszatérési értéke vagy paramétere, de most a könnyebb megértés miatt ettől tekintsünk el. Neve mindig kell, hogy legyen, ezzel tehát nem lesz problémánk)

 

Ahhoz, hogy függvényekről tudjunk beszélni, ismernünk kell a változókat is, de ezen bloggcikknek nem célja mind a két terület bemutatása, ezért az egyszerűsítés érdekében, fogadjuk el az alábbi tényeket:

  • Egy változó nem más, mint egy átmeneti tárolója egy bizonyos értéknek
  • A változó értékét tetszőlegesen lehet írni és olvasni
  • Minden változónak van típusa, például:
    • int: egész szám típus
    • double: nem egész szám típus

(more…)

Függvény és Változó nevek

Ebben a témában: Alapok, C Programozas, Java Programozas

Sokan lényegtelennek tartják az egyes függvények vagy változók precíz elnevezését a mindennapi munka során, azonban szerintem ez egy nagyon fontos pont. Funkcionalitás tekintetében lehet, hogy nem tűnik olyan lényegesnek mindez, azonban a kód karbantarthatóságát tekintve ez az egyik legfontosabb szempont.

 

 

Azért egy nehéz kérdés ez, mert a fejlesztőnek, aki épp implementálja az adott függvényt, annak triviális, hogy egy változó épp mikor mit jelent. Ezért szinte fel sem tűnik neki, hogy 2 hét vagy 2 év múlva mennyire értelmezhetetlen is lesz majd a kód. Sajnos sokszor láttam már ilyet illetve nekem is kellett már ilyen minőségű kódot megértenem. Nem egy nagy öröm ez, remélem nektek nem kell ezt átélni, azonban sajnos az eddigi tapasztalatom nem ezt mutatja. Nézzük meg az elméletet, hogy mikor ideális szerintem egy függvény vagy egy publikus, globális változó elnevezése:

  1. A programozás nyelve az angol. Angol a függvénynév, a változó, a komment, minden.
  2. A név hierarchia szerint épül fel (azért ezt nem érdemes túlzásban vinni, 1-2, nagyon maximum 3 szint bőven elegendő)
  3. A hierarchiai szintek általában rövidítve szerepelnek
  4. Az utolsó rész legyen a függvény vagy változó célja. Ez általában egy szabadabb rész, tetszőleges, rövid! tartalommal
  5. A függvény vagy változó végén postfix-ként szerepel a típus megnevezés
  6. Egybeírás esetén minden új szó nagybetűvel kezdődik
  7. Elválasztás esetén az elválasztó karakter az alul vonás „_”

 

A fenti szabályrendszert én mindig függvényekre és publikus, globális változókra alkalmazom. A függvény lokális változóknak és a függvény paramétereknek az elnevezésében általában nem használok hierarchia szinteket, ennyiben egyszerűsödik a dolog.

Nézzünk egy jó példát egy C függvényre, ami 3 számot tud összeadni:

int Pti_SumOfThreeNumbers_s16(int NumberOne_s16, int NumberTwo_s16, int NumberThree_s16);

 

Egy függvény ami megjeleníti az eredményt:

void Pti_PrintResult(int Result_s16)

 

Érdemes nagyon odafigyelni az elnevezésekre, mert ha valaki belenéz az implementációnkba, akkor ez az első dolog amit meglát. Fontos, hogy könnyen és gyorsan meg lehessen érteni a forráskódunkat, ellenkező esetben mindenkitől sokkal több időt rabol el ez a feladat mint amennyit feltétlenül szükséges lenne és akaratlanul is ellenszenvet válthatunk ki másokban. A mai komplexitású SW-ekben pedig a mindennapi munka része, hogy a kollégáink által írt kódot kell tudnunk megérteni. A problémákat, összetűzéseket azonban egy kicsi odafigyeléssel el lehet kerülni.

(more…)

Ismétléses utasítások – A While Ciklus

Ebben a témában: Alapok, C Programozas, Java Programozas

Egy korábbi cikkemben már bemutattam a ciklikus végrehajtás fontosságát. Java és C programozásban egy ciklus létrehozására két fajta nyelvi elem létezik, a korábban már bemutatott For ciklus és az úgynevezett While ciklus.

 

A két nyelvi elem mindig átjárható, tehát egy adott szituációra bármelyik használható. Azt, hogy ki melyiket választja az inkább helyzet és megszokás kérdése. A leglényegesebb különbség a kettő között, hogy amíg a For ciklusnál a létrehozáskor egy sorban meg tudjuk adni a feltételt és a ciklus számlálót, addig a While ciklusnál csak a feltételt tudjuk közvetlenül definiálni. A ciklusváltozó kezelését magunknak kell megoldani! Ez tipikusan azt jelenti, hogy a ciklus előtt már létre kell hoznunk a ciklusváltozót és a cikluson belülről kell növelnünk az értékét, ciklusonként egyszer.

 

Röviden vegyük át ismét a ciklusok működésének alapelvét:

  1. Meddig kell ismételni az utasításmagot, feltétel megadása
  2. Maga az utasításmag

A While ciklusnak két fajtája van:

 

  1. Elöl Tesztelő Ciklus

Azért elöl tesztelő, mert már az első végrehajtás előtt ellenőrzi a megadott feltételt, tehát nem biztos, hogy a ciklus egyszer is végre fog hajtódni. Az elöl tesztelő ciklus szintaktikailag így épül fel:

while(condition)

{

}

 

Látható, hogy a létrehozása jóval kevesebb karakterből megoldható mint egy For ciklus esetében (ez azonban nem biztos, hogy előny), mindössze a While kulcsszót és egy feltételt kell leírnunk. A ciklus addig fut amíg a feltétel teljesül. Nézzünk egy konkrét példát, adjuk össze az egész számokat 1-től 5-ig:

int baseNumber = 5;

int result = 0;

while (baseNumber > 0)

{

result = result + baseNumber;

baseNumber--;

}

 

Amire ennél a formánál nagyon oda kell figyelni, az a ciklusváltozó kezelése a cikluson belül. Nem hívja fel rá semmi a figyelmünket, ezért könnyen el tud felejtődni!

Nézzük meg ugyanezt a feladatot For ciklussal:

int result = 0;

for(int baseNumber = 5; baseNumber > 0; baseNumber--)

{

result = result + baseNumber;

}

 

 

  1. Hátul Tesztelő Ciklus

(more…)

Programok működésének felépítése

Ebben a témában: Alapok, C Programozas, Java Programozas

Amikor valaki elkezd programozással foglalkozni, programozást tanulni, akkor mindig az első leckék között szerepel, hogy megértsük, hogy hogyan is működnek a programok. Milyen sorrendben hajtódnak végre egymás után az utasítások, hogyan épül fel egy program.

 

Egy program nem más, mint utasítások szekvenciális végrehajtásának halmaza.

Kezdjük a legegyszerűbb eshetőséggel, az egyszálú programokkal. Mit jelent ez?
Azt, hogy van egy fő szál, ami szekvenciálisan hajtja végre az egymás után következő utasításokat. Nézzünk erre egy példát:

int a = 2;

int b = 3;

int c, d;

c = a+b;

d = c*a;


Hogyan fognak egymás után lefutni az utasítások?

Felülről lefelé. Először létrejönnek egymás után a változók „a”, „b”, „c” és „d”. A változók vagy úgy jönnek létre, hogy van valamilyen dedikált kezdőértékük („a”, „b”) vagy úgy, hogy csak létrejön, de nem kap értéket („c”, „d”). Ezután kiszámoljuk „c” értékét majd végül pedig „d” értékét. Nincsenek kereszthatások és nincsenek ugrások sem. Mi történik, ha megcserélem „c” és „d” kiszámításának sorrendjét?

Mivel „d”-nek bemenete „c”, de mivel „c” csak „d” után kap számolt értéket, ezért nem tudjuk megmondani pontosan, hogy mi lesz „d” értéke. Azonban a program továbbra is működőképes marad, de biztosan kapunk egy hatalmas figyelmeztető üzenetet, hogy úgy használunk fel egy változót, hogy annak értékét mi magunk még sosem állítottuk. De hogyan lehetséges ez?
Úgy, hogy valamilyen előre nem definiált értéket minden változó kap a létrehozásakor, ha mi magunk nem állítunk be semmilyen kezdőértéket. Ez az érték igazából bármi lehet, nem lehet előre megmondani. Ez egy nagyon gyakori hiba és veszélyes szituáció, éppen ezért komoly figyelmeztetéseket küld ilyen esetben a fordító és a fejlesztő környezet is, ha észreveszi. Éppen ezért a legjobb megközelítés, amit én mindenkinek kifejezetten ajánlani szoktam, hogy mindig minden változónak adjunk kezdőértéket! Ez sokszor feleslegesnek tűnik, de ha egyszer bekerül a napi rutinba akkor sok fejfájást meg tudunk spórolni.


Függvények

Egy jól strukturált kód első ismérve a függvények megfelelő minőségű és mennyiségű használata. Mi is pontosan egy függvény?
A programozásban használt függvények analóg módon működnek a matematikában megszokott függvényekhez. Azaz valamilyen bemeneti adatokból valamilyen módon előállít kimeneti adatot vagy adatokat, áttranszformálja a bemeneti adatokat kimeneti adatokká. Azt, hogy ezt pontosan hogyan teszi, az már a függvénynek a belső hatásköre. Ezért ami fontos, hogy minden függvénynek (mostmár a programozásbeli függvényekről beszélek) kell, hogy legyen egy jól definiált bemeneti és kimeneti leírása. Pontosan milyen bemeneti adatokból milyen kimeneti adatokat fog előállítani. Persze a belső működésének a leírása is mindig szükséges, de vannak olyan szituációk amikor az nem feltétlenül fontos számunkra, csakis a bemenetek és a kimenetek.


Hogyan néz ki egy függvény deklarációja a programozásban?

VisszatérésiÉrtékTípusa FüggvényNév(Parameter1Típusa Parameter1, Parameter2Típusa Parameter2, …, ParameterNTípusa ParameterN) { … }


Deklaráljuk az összeadás függvényt, ami 2 számot ad össze:

int SumOfTwoNumbers( int Number1, int Number2) { … }

VisszatérésiÉrtékTípusa int
FüggvényNév SumOfTwoNumbers
Parameter1Típusa int
Parameter1 Number1
Parameter2Típusa int
Parameter2 Number1



Minden függvénynek kötelező, hogy legyen be és kimenete is?

(more…)

Ismétléses utasítások – A For Ciklus

Ebben a témában: Alapok, C Programozas, Java Programozas

Az előző cikkben már megnéztük az egyik legalapvetőbb programozási eszközt, a feltétel vizsgálatot. Most ehhez hasonlóan szeretnék bemutatni egy szintén nagyon alapvető elemet, az ismétléses utasítás végrehajtást. Gyakran találkozunk olyan feladattal, amikor van egy nagyobb bemeneti adathalmaz és annak minden elemén ugyanazt az utasítást kell végrehajtani.


Ha a mostani ismereteinkkel közelítenénk meg ezt a problémát és feltesszük, hogy ismerjük, hogy pontosan mennyi bemeneti adatunk van, akkor minden feldolgozási lépést leprogramoznánk minden bemenetre. Ez a módszer maximum 5-10 adat esetén még esetleg működőképes lehet, de el lehet képzelni, hogy több száz vagy akár még több adat esetén már kivitelezhetetlen. Pontosan ilyen problémákra találták ki az utasításismétlést, ami az alábbiak szerint épül fel:

  1. Meddig kell ismételni az utasításmagot
  2. Maga az utasításmag

 

Addig hajtja végre a program újra és újra ugyan azt a blokkot, ameddig a megadott feltétel teljesül. Tehát mondjuk, ha ötvenszer kell végrehajtani egy kiírató utasítást, akkor az valahogy így nézne ki:

i := 0

[i < 50]

{

Kiíratás

}

 

Ennek megvalósítására több szintaktikai eszköz létezik C-ben és Java-ban is, de ezek egyenértékűek, átjárhatóak. Én azt gondolom, hogy a legismertebb az úgynevezett FOR Ciklus, ami az alábbiak szerint épül fel:

for(inicializálás; feltételvizsgálat; paraméter kezelés)

{

utasításmag

}

  1. Egy FOR Ciklusnak 3 bemenete van:
    1. inicializálás – az első ciklus előtt egyszer fog megtörténni
    2. feltételvizsgálat – minden ciklus után egyszer fog megtörténni a paraméter kezelés után
    3. paraméter kezelés – minden ciklus után egyszer fog megtörténni a feltételvizsgálat előtt
  2. Utasítás mag – minden ciklusban végrehajtódik egyszer

Ez egy nagyon tömör és nagyon hatékony módszer, hogyha ugyanazokat az utasításokat kell egymás után többször is végrehajtanunk. A 3 bemeneti paraméter között nem kötelező, hogy szoros összefüggés legyen, de itt ténylegesen csak olyan adatokat szabad megadni, ami a végrehajtás számát befolyásolja. Illetve a mostani feltételvizsgálat hasonlóképen működik, mint a múltkor bemutatott feltételvizsgálat, lehet egyszerű vagy komplex. Ez a rész tetszőleges feltételt tartalmazhat, figyelhet eseményeket vagy határokat egy bemeneti adathalmazon. Amit még fontos kiemelni, hogy az inicializáló részben definiált változó, az utasításmagban is elérhető.

 

Az előbbi pszeudokód megvalósítása FOR Ciklussal:

for(int i=0; i<50; i++)

{

System.out.println(„Hello_” + i);

}

 

Nézzünk egy nagyon egyszerű gyakorlati példát:
Kérjünk be a felhasználótól számokat, vesszővel elválasztva, majd adjuk meg a számok átlagát.

 

(more…)