A típusrendszer: változók, var, konstansok

1Mi a változó?

A változó (variable) elnevezett tárolóhely a memóriában. Képzeld feliratozott doboznak: a felirat a név, a doboz mérete és alakja a típus, a tartalma az érték — és a tartalom később cserélhető.

int kor = 17;

Szedjük szét, ahogy az A6-ban az első sort:

A deklaráció után a változó használható — kiírható, számolható vele, és új értéket is kaphat:

int kor = 17;
Console.WriteLine(kor);   // 17

kor = 18;                 // új érték — a régi felülíródik
Console.WriteLine(kor);   // 18

2A C# erősen típusos — a fordító őrzi a dobozokat

A típus a deklarációnál egyszer és mindenkorra rögzül. A JavaScriptben ehhez képest a változó bármikor bármit tárolhat:

// JavaScript — ez simán lefut:
let adat = 5;
adat = "szöveg";     // a szám helyére szöveg került, senki sem szól

// C# — ugyanez fordítási hiba:
int adat = 5;
adat = "szöveg";     // ⛔ CS0029: Cannot implicitly convert type 'string' to 'int'

Ez a típusbiztonság, amit az A3-ban a CLR szolgáltatásai közt láttál — és a gyakorlatban azt jelenti: az ilyen hibát te látod meg fordításkor, nem a felhasználó futás közben. Elsőre szigorúnak tűnik, valójában a legjobb barátod.

3Az öt alaptípus — első kör

Most csak bemutatkoznak; mindegyikre visszatérünk részletesen a blokk további fejezeteiben.

Három jelölési szabály, ami sok kezdő hibát megelőz:

1. Idézőjel = string, aposztróf = char. A "A" szöveg (egybetűs), az 'A' karakter.
2. A tizedes elválasztó a kódban mindig PONT (3.14) — akkor is, ha magyarul vesszőt írnánk.
3. A számok jelölés nélkül állnak: 42 — se idézőjel, se aposztróf. A "42" nem szám, hanem szöveg!

string nev = "Anna";
int pontszam = 87;
double magassag = 1.72;
char monogram = 'A';
bool sikeres = true;

Console.WriteLine(nev);
Console.WriteLine(pontszam);

4A var — típuskövetkeztetés, nem típustalanság

A var kulcsszóval a típus kiírását a fordítóra bízhatod:

var pontszam = 10;        // a fordító kikövetkezteti: int
var nev = "Anna";         // string
var magassag = 1.72;      // double

A var NEM a JavaScript let-je! A típust nem elhagyjuk, hanem a fordító kikövetkezteti a kezdőértékből — és onnantól ugyanolyan kőbe vésett, mintha kiírtad volna:

var pontszam = 10;
pontszam = "sok";         // ⛔ CS0029 — a pontszam bizony int!

Két következmény: a var-nak mindig kell kezdőérték (miből következtetne?), és csak lokális változóra használható.

5Konstansok — ami sosem változik

Ha egy érték a program élete alatt garantáltan állandó, jelöld const-tal:

const int MaxProba = 10;
const double AfaKulcs = 0.27;

MaxProba = 12;            // ⛔ CS0131 — konstansnak nem adhatsz új értéket

Miért jó?

• Kimondja a szándékot: aki olvassa, tudja — ez nem fog változni.
• A fordító védi: véletlenül sem írható felül.
• Egy helyen módosítható: ha jövőre 12 próba lesz, egyetlen sort írsz át, nem vadászod végig a kódban a 10-eseket. A „kódba szórt csupasz számot” a szakma bűvös számnak (magic number) hívja — a konstans ellene a gyógyszer.

Elnevezés: a konstans PascalCase — mint látod, a MaxProba nagybetűvel kezdődik.

6Minden objektum — most már a te változóid is

Az A3-ban láttad: az int a System.Int32 álneve, és minden típus a System.Object leszármazottja. Most már saját változókon próbálhatod ki:

int kor = 17;
string nev = "Anna";

Console.WriteLine(kor.GetType());    // System.Int32
Console.WriteLine(nev.GetType());    // System.String

A rövid álnevet gépeljük — de amikor a hibaüzenetben vagy a debuggerben Int32-t látsz, most már tudod: ugyanarról beszéltek.

7Elnevezési konvenciók

Mit enged a nyelv?

Az azonosító betűvel vagy aláhúzással kezdődik, utána betű, számjegy és _ állhat; a kis- és nagybetű különbözik (kor ≠ Kor — A6); kulcsszó (int, class, …) nem lehet változónév.

Mit vár el a stílus?

1. Lokális változó és konstans: változó camelCase (vegosszeg, hatralevoProba), konstans PascalCase (MaxProba).
2. Beszédes név: a név mondja meg, MI van a dobozban. hatralevoProba — jó; hp, x2, asd — egy hét múlva neked is rejtvény.
3. A tananyagban magyarul nevezünk el (ékezet nélkül): pontszam, nyertes, tippSzama — a keretrendszer nevei maradnak angolul (Console, WriteLine).
4. A PascalCase másik fele (metódus, osztály) a D és H blokkban általános lesz — a szabályt már ismered: a Main és a WriteLine is így épül.

8Gyakorlat — változók a Locals ablakban

Az A9-ben megígértük: a debugger a változóknál válik igazán hasznossá. Itt az idő.

1. Új projekt: Console App, név: Valtozok, .NET 10. Gépeld be:

int kor = 17;
string nev = "Anna";
double magassag = 1.72;

Console.WriteLine(nev);
Console.WriteLine(kor);

kor = kor + 1;
Console.WriteLine(kor);

2. Tegyél töréspontot az első sorra (F9), indíts F5-tel.
3. Nyisd meg alul a Locals ablakot (ha nem látszik: Debug → Windows → Locals).
4. Lépkedj F10-zel, és figyeld a Locals-t: a változók sorban értéket kapnak — előbb kor = 17, aztán megjelenik a nev, a magassag…
5. A kor = kor + 1; sornál állj meg: a Locals-ban a kor pirosra vált, amikor 17-ről 18-ra nő. A doboz tartalma a szemed előtt cserélődött ki!
6. Kísérletezz a hibákkal is: írd be, hogy kor = "sok"; — nézd meg a CS0029-et az Error Listben, aztán javítsd vissza. Commitold a kész gyakorlatot (A7!).

9Feladatok

int a = 5;
int b = a;
a = 10;
Console.WriteLine(a);
Console.WriteLine(b);

10Önellenőrző kvíz

11Fogalomtár

12Összegzés