AlapokC ProgramozasJava Programozas

Változók a programozásban

Változók a programozásban

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.

 

Változó létrehozása

Az első lépés, hogy létre kell hozunk a változót. Ezt az alábbi formátumban tudjuk megtenni:

változóTípusa változóNeve;

  • Ahol a változóTípusa helyére egy típust kell megadnunk. A változó típusokat mindig az adott programozási nyelv definiálja, mi ezek közül tudunk választani.
  • A változóNeve helyére pedig a változó neve kerül. A név tetszőleges lehet, de fontos, hogy minden változónak egyedi neve kell, hogy legyen. Ezen a néven fogunk majd tudni hivatkozni rá később.

Nézzünk egy példát:

Hozzunk létre egy változót, ami tárolja a koromat (szám):

               int myAge;

Hozzunk létre egy változót, ami tárolja a nevemet (szöveg):

               String myName;

 

Változók használata

Rendben, most már tudjuk a változók elméletét és most már azt is tudjuk, hogyan tudunk változókat létrehozni. Ha már van változónk, akkor nézzük meg, hogy hogyan tudunk adatot beletenni.

Ha egy változónak értéket akarunk adni, akkor azt mindig az egyenlőségjellel tudjuk megtenni. Egy változó kétféleképen kaphat értéket:

  1. Létrehozáskor. Ez az úgynevezett változó inicializáció (Initialization) vagy magyarul kezdőérték beállítás. Ebben az esetben a változó a megadott értékkel fog létrejönni, ez lesz a változó kezdőértéke. Tehát változó létrehozása + értékadás:

változóTípusa változóNeve = érték;

  1. Vagy a program futása során bármikor. Egy már létező, tehát korábban már létrehozott változónak az alábbi módon tudunk értéket adni:

változóNeve = érték;

Ha egy olyan változónak akarunk értéket adni, amit korábban már valahol létrehoztunk, akkor a változó típusát már nem kell újra kiírnunk, csak a nevét. Az egyenlőségjel jobb oldalán pedig olyan típusú adat állhat, ami megegyezik a változó típusával:

Létrehozás + Kezdőérték beállítása:

int myAge = 30;

String myName = ”B. Tamas”;

Érték módosítás:

myAge = 78;

myName = ”Karoly”;

 

Változó értékének kiolvasása

Most már létre is tudjuk hozni a változókat és értékeket is tudunk nekik adni. Nem maradt más hátra, mint hogy kiolvassuk a változó tartalmát. Ha ki akarjuk olvasni a változó tartalmát, akkor egyetlen dolgot kell tennünk: A megfelelő helyen leírjuk a változó nevét! Legyen az kiírató utasítás vagy egy adat további használata.

Változó értékének kiíratása:

System.out.println(”Dear ” + name);

Változó értékének kiolvasása és felhasználása egy másik változóhoz:

int myNumber1 = 12;

int myNumber2 = 30;

int result = 0;

result = myNumber1 + myNumber2;

Mennyi lesz a result változó értéke?

Az eddig tárgyal logika alapján a result változó új értéket kap, méghozzá az egyenlőségjel jobb oldalán szereplő értéket. Milyen érték szerepel az egyenlőségjel jobb oldalán? 12 és 30, azaz a myNumber1 és myNumber2 változók aktuális értéke.

Ez alapján pedig a result változó 42-es értéket fog felvenni.

Nézzünk egy teljes kódrészletet:

public class Main {

public static void main(String[] args) {

String name = "Tamas";

int myNumber1 = 12;

int myNumber2 = 30;

int result = 0;


/** Do the basic Mathematical methods */

/** SUM */

result = myNumber1 + myNumber2;

System.out.println("Dear " + name + "! Sum of myNumber1 and myNumber2: " + result);


/** SUBSTRACTION */

result = myNumber1 - myNumber2;

System.out.println("Dear " + name + "! Subtraction of myNumber1 and myNumber2: " + result);


/** MULTIPLICATION */

result = myNumber1 * myNumber2;

System.out.println("Dear " + name + "! Multiplication of myNumber1 and myNumber2: " + result);

}

}

 

 

Végszó

A változók használata minden programozási nyelvben támogatott, hiszen ez egy nélkülözhetetlen mechanizmus. Épp ezért remélem érthetőek voltak a fenti gondolatokat és tudtam egy kicsit segíteni. Természetesen erről és még jóval többről is beszélek a Java Tanfolyamomban, így ha érdekel a téma mélyebben, akkor nézz szét azon az oldalon is.

A példaprogramot innen tudjátok letölteni. Írjátok át, gyakoroljatok és ha email-ben elkülditek nekem, akkor szívesen megnézem.

Ha úgy érzed, hogy ez a program még egy kicsit bonyolult volt neked, akkor ajánlom a Hello World kezdőprogramot. Ha viszont mennél tovább egy új témára, akkor a Függvények blogcikkem lesz a Neked való!

Bajor Tamás - Programozz Te Is!

Szia, Bajor Tamás vagyok, a Programozz Te Is oldal alapítója és oktatója. Köszi, hogy itt vagy és éppen az én cikkem olvasására fordítod a drága idődet! Azért dolgozom minden nap, hogy neked segítsek a programozás világában minél profibban elmélyülni. A cikkek egyetlen írójaként rengeteg munkát és energiát fektetek mind az oldalba, mind pedig az oktatásba!

Arra kérlek, ha tetszett cikk amit olvastál vagy szívesen veszed az ingyenes anyagokat akkor dobj egy Like-ot a Facebook-on, ezzel is támogatva a munkámat. Neked ez egy apró kattintás, nekem pedig hatalmas segítség!