Metódusok.

namespace _09_Metodusek // A namespace (névtér) összefogja az ehhez a példához tartozó kódelemeket; ennek a névtérnek a neve _09_Metodusek.
{ // Itt kezdődik a névtér kódblokkja.
    internal class Program // A Program nevű osztály deklarációja; ebben lesz a Main és az összes most bemutatott METÓDUS, pontosabban metódus.
    { // Itt kezdődik a Program osztály törzse.
        static void Main(string[] args) // A Main a program belépési pontja; maga is egy static és void metódus.
        { // Itt kezdődik a Main metódus törzse.
            Console.WriteLine("A program elindult.\n"); // Kiírjuk, hogy a program futása elkezdődött; a \n még egy üres sort is létrehoz.

            // 1. PÉLDA – EGYSZERŰ static void METÓDUS MEGHÍVÁSA.
            EgyszeruMetodus(); // Meghívjuk az EgyszeruMetodus() metódust; a program végrehajtja annak törzsét, majd visszatér ide a Main-be.

            // 2. PÉLDA – static void METÓDUS, AMELYBEN for CIKLUS FUT.
            SzamoljOtosig(); // Meghívjuk a SzamoljOtosig() metódust; a ciklus nem a Main-ben, hanem ebben a külön metódusban található.

            // 3. PÉLDA – ÉRTÉKET VISSZAADÓ METÓDUS.
            int negyzet = Negyzet(6); // A Negyzet(6) meghívás visszaad egy int értéket; ezt a negyzet változóban tároljuk.
            Console.WriteLine($"6 négyzete: {negyzet}\n"); // Kiírjuk a METÓDUStől visszakapott értéket, majd egy üres sort kezdünk.

            // 4. PÉLDA – Random OBJEKTUM ÁTADÁSA EGY METÓDUSNEK.
            Random random = new Random(); // Létrehozunk egyetlen Random objektumot, amelyet a véletlenszámot készítő metódusnak is át tudunk adni.
            int veletlen = VeletlenSzam(random, 1, 11); // A metódusnak három argumentumot adunk át; a visszakapott véletlen egész számot eltároljuk.
            Console.WriteLine($"A METÓDUS által generált véletlen szám 1 és 10 között: {veletlen}\n"); // Kiírjuk a visszakapott véletlen számot.

            // 5. PÉLDA – NEM static METÓDUS MEGHÍVÁSA.
            Program program = new Program(); // Létrehozunk egy Program típusú objektumot, mert a nem static metódust nem hívhatjuk meg közvetlenül a static Main-ből.
            program.NemStatikusMetodus(); // A létrehozott program objektumon keresztül meghívjuk a nem static metódust.

            Console.WriteLine("\nA program visszaért a Main végére."); // Ez a sor csak az előző METÓDUShívások befejezése után hajtódik végre.
        } // Itt ér véget a Main metódus törzse.

        static void EgyszeruMetodus() // static: példány nélkül hívható; void: nem ad vissza értéket; a metódus neve EgyszeruMetodus; nincs paramétere.
        { // Itt kezdődik az EgyszeruMetodus() metódus törzse.
            Console.WriteLine("Most az EgyszeruMetodus() fut.\n"); // A metódus egyetlen feladata, hogy kiírja ezt a szöveget, majd a végén visszaadja a vezérlést a hívó kódrésznek.
        } // Itt ér véget az EgyszeruMetodus() metódus.

        static void SzamoljOtosig() // Ez is static void metódus: példány nélkül hívható, és nem ad vissza értéket.
        { // Itt kezdődik a SzamoljOtosig() metódus törzse.
            Console.WriteLine("Most a SzamoljOtosig() fut:"); // Jelezzük a konzolon, hogy melyik metódus végrehajtása kezdődött el.

            for (int i = 1; i <= 5; i++) // A ciklus i = 1-ről indul, 5-ig fut, és minden kör végén eggyel növeli i értékét.
            { // Itt kezdődik a for ciklus törzse.
                Console.Write($"{i} "); // Kiírjuk az i aktuális értékét ugyanabba a sorba.
            } // Itt ér véget a for ciklus törzse; ha a feltétel még igaz, következik a következő ismétlés.

            Console.WriteLine("\n"); // A számsor után új sort és még egy üres sort írunk.
        } // Itt ér véget a SzamoljOtosig() metódus; a program visszatér ahhoz a sorhoz, ahonnan meghívtuk.

        static int Negyzet(int szam) // A metódus egy int típusú szam paramétert kap, és a void helyett int szerepel, ezért int értéket kell visszaadnia.
        { // Itt kezdődik a Negyzet() metódus törzse.
            int eredmeny = szam * szam; // A paraméterként kapott számot megszorozzuk önmagával, és az eredményt egy helyi változóban tároljuk.
            return eredmeny; // A return visszaadja az eredmeny értékét annak a kódrésznek, amely meghívta a Negyzet() metódust.
        } // Itt ér véget a Negyzet() metódus.

        static int VeletlenSzam(Random random, int minimum, int maximum) // Három paramétert várunk: egy Random objektumot és két int határértéket; a metódus int értéket ad vissza.
        { // Itt kezdődik a VeletlenSzam() metódus törzse.
            int szam = random.Next(minimum, maximum); // A Next() a minimumot még engedi, a maximumot már nem; például 1 és 11 esetén 1..10 lehet az eredmény.
            return szam; // Visszaadjuk a létrehozott véletlen egész számot a hívó kódrésznek.
        } // Itt ér véget a VeletlenSzam() metódus.

        void NemStatikusMetodus() // Ez a metódus NEM static; void, tehát nem ad vissza értéket, de a meghívásához szükség van egy Program objektumra.
        { // Itt kezdődik a NemStatikusMetodus() metódus törzse.
            Console.WriteLine("Most a NemStatikusMetodus() fut."); // Kiírjuk, hogy sikeresen meghívtuk a Program egyik példányához tartozó metódust.
        } // Itt ér véget a NemStatikusMetodus() metódus.
    } // Itt ér véget a Program osztály törzse.
} // Itt ér véget a _09_Metodusek névtér.


/*
 * METÓDUS VAGY METÓDUS?
 * ----------------------
 *
 * A hétköznapi programozási szóhasználatban gyakran egyszerűen
 * "METÓDUSnek" nevezzük az olyan különálló kódrészleteket, amelyeket
 * név alapján meg lehet hívni.
 *
 * C#-ban azonban az osztályon belül létrehozott ilyen METÓDUSek pontosabb
 * neve: METÓDUS.
 *
 * Ebben a programban például:
 *
 *     static void EgyszeruMetodus()
 *
 * technikailag egy metódus, mert a Program osztályhoz tartozik.
 *
 * A tananyagban a "METÓDUS" és a "metódus" szót az elején nyugodtan
 * használhatjuk egymás mellett, de érdemes tudni, hogy C#-ban a metódus
 * a pontosabb megnevezés.
 *
 * Már eddig is rengeteg metódust használtunk:
 *
 *     Console.WriteLine()
 *     Console.ReadLine()
 *     int.Parse()
 *     random.Next()
 *     Math.Round()
 *
 * A különbség most az, hogy már nemcsak mások által elkészített
 * metódusokat használunk, hanem SAJÁT metódusokat is készítünk.
 */


/*
 * MIÉRT HASZNÁLUNK METÓDUSEKET / METÓDUSOKAT?
 * ---------------------------------------------
 *
 * Egy program minden utasítását beleírhatnánk a Main() metódusba is.
 * Kis programnál ez még működhet, de hamar áttekinthetetlenné válna.
 *
 * A metódusok segítségével a programot kisebb, névvel ellátott
 * feladatokra bonthatjuk.
 *
 * Például ahelyett, hogy a Main-ben lenne egy hosszabb számláló ciklus:
 *
 *     for (int i = 1; i <= 5; i++)
 *     {
 *         Console.Write($"{i} ");
 *     }
 *
 * készíthetünk egy külön metódust:
 *
 *     static void SzamoljOtosig()
 *     {
 *         for (int i = 1; i <= 5; i++)
 *         {
 *             Console.Write($"{i} ");
 *         }
 *     }
 *
 * és a Main-ben már csak ezt írjuk:
 *
 *     SzamoljOtosig();
 *
 * Előnyei:
 *
 *     - a Main rövidebb és áttekinthetőbb lesz;
 *     - a feladatnak beszédes nevet adhatunk;
 *     - ugyanazt a metódust többször is meghívhatjuk;
 *     - a programot kisebb részekre tudjuk bontani;
 *     - a hibákat is könnyebb lehet megtalálni.
 */


/*
 * EGY EGYSZERŰ METÓDUS FELÉPÍTÉSE
 * -------------------------------
 *
 * Nézzük ezt:
 *
 *     static void EgyszeruMetodus()
 *     {
 *         Console.WriteLine("Most az EgyszeruMetodus() fut.");
 *     }
 *
 * A fejléc felépítése:
 *
 *     static      void      EgyszeruMetodus      ()
 *       ↓           ↓               ↓              ↓
 *    módosító    visszatérési     metódus        paraméterek
 *                  típus            neve
 *
 * Kezdőként ebből most négy dolgot érdemes felismerni:
 *
 * 1. static
 *    A metódus közvetlenül a Program osztályhoz tartozik.
 *    A static Main-ből ezért közvetlenül meghívható.
 *
 * 2. void
 *    A metódus nem ad vissza értéket.
 *
 * 3. EgyszeruMetodus
 *    Ez a metódus neve.
 *
 * 4. ()
 *    A zárójelben lennének a paraméterek.
 *    Itt üres, tehát ez a metódus nem vár bemenő adatot.
 *
 * A { } kapcsos zárójelek között található a metódus törzse,
 * vagyis azok az utasítások, amelyek a meghívásakor lefutnak.
 */


/*
 * DEKLARÁCIÓ ÉS MEGHÍVÁS NEM UGYANAZ
 * ----------------------------------
 *
 * Amikor ezt leírjuk:
 *
 *     static void EgyszeruMetodus()
 *     {
 *         Console.WriteLine("Most az EgyszeruMetodus() fut.");
 *     }
 *
 * akkor LÉTREHOZZUK, vagyis deklaráljuk/definiáljuk a metódust.
 *
 * Ettől még nem feltétlenül fut le.
 *
 * A futtatásához meg kell hívni:
 *
 *     EgyszeruMetodus();
 *
 * A meghíváskor a program:
 *
 *     1. eljut az EgyszeruMetodus(); sorhoz;
 *     2. átugrik az EgyszeruMetodus() törzséhez;
 *     3. végrehajtja az ott lévő utasításokat;
 *     4. a metódus végén visszatér a hívás utáni következő sorhoz.
 *
 * Fontos tehát:
 *
 *     static void EgyszeruMetodus()   -> a metódus létrehozása
 *
 *     EgyszeruMetodus();              -> a metódus meghívása
 */


/*
 * void – AMIKOR A METÓDUS NEM AD VISSZA ÉRTÉKET
 * ---------------------------------------------
 *
 * A void jelentése leegyszerűsítve:
 *
 *     "ez a metódus nem ad vissza értéket"
 *
 * Például:
 *
 *     static void EgyszeruMetodus()
 *
 * A metódus kiír valamit a képernyőre, tehát CSINÁL valamit,
 * de a meghívó kódrésznek nem ad vissza egy felhasználható értéket.
 *
 * Ezért ezt egyszerűen meghívjuk:
 *
 *     EgyszeruMetodus();
 *
 * de ilyet nem írunk:
 *
 *     int x = EgyszeruMetodus();
 *
 * mert nincs int vagy más érték, amit el lehetne tárolni.
 *
 * A Main is void ebben a programban:
 *
 *     static void Main(string[] args)
 *
 * tehát az eddig minden programban látott "void" ugyanazt jelenti.
 */


/*
 * NEM void – AMIKOR A METÓDUS ÉRTÉKET AD VISSZA
 * ---------------------------------------------
 *
 * Nézzük a Negyzet() metódust:
 *
 *     static int Negyzet(int szam)
 *     {
 *         int eredmeny = szam * szam;
 *         return eredmeny;
 *     }
 *
 * Itt a void helyén int áll:
 *
 *     static INT Negyzet(...)
 *
 * Ez azt jelenti, hogy a metódus egy int típusú értéket ad vissza.
 *
 * Ezért a metódus törzsében szerepel:
 *
 *     return eredmeny;
 *
 * A return szó szerint visszaadja az értéket a hívás helyére.
 *
 * Ha ezt írjuk:
 *
 *     int negyzet = Negyzet(6);
 *
 * akkor a történés leegyszerűsítve:
 *
 *     Negyzet(6)
 *         ↓
 *     6 * 6
 *         ↓
 *     return 36
 *         ↓
 *     int negyzet = 36;
 *
 * Vagyis a metódushívást szinte úgy képzelhetjük el,
 * mintha a végén a visszaadott érték kerülne a helyére.
 */


/*
 * A return UTASÍTÁS
 * -----------------
 *
 * A return egy értéket visszaadó metódus egyik legfontosabb eleme.
 *
 * Például:
 *
 *     static int Negyzet(int szam)
 *     {
 *         return szam * szam;
 *     }
 *
 * Ez rövidebb változata lenne a programban használt megoldásnak:
 *
 *     static int Negyzet(int szam)
 *     {
 *         int eredmeny = szam * szam;
 *         return eredmeny;
 *     }
 *
 * A kettő eredménye ugyanaz.
 *
 * Az int visszatérési típus miatt a metódusnak int értéket kell
 * visszaadnia.
 *
 * Például ez hibás lenne:
 *
 *     static int Negyzet(int szam)
 *     {
 *         return "harminchat";
 *     }
 *
 * mert a "harminchat" string, miközben a metódus int visszatérési
 * típust ígért.
 */


/*
 * PARAMÉTER ÉS ARGUMENTUM
 * ----------------------
 *
 * A metódusnak adatot is átadhatunk.
 *
 * Például a deklarációban:
 *
 *     static int Negyzet(int szam)
 *
 * az:
 *
 *     int szam
 *
 * egy PARAMÉTER.
 *
 * A felépítése:
 *
 *     int      szam
 *      ↓         ↓
 *    típus    paraméter neve
 *
 * Amikor meghívjuk:
 *
 *     Negyzet(6)
 *
 * akkor a 6 az ARGUMENTUM, vagyis a híváskor ténylegesen átadott érték.
 *
 * Kezdőként elég ezt így megjegyezni:
 *
 *     paraméter  -> a metódus deklarációjában szereplő változó
 *     argumentum -> a meghíváskor átadott konkrét érték
 *
 * A metóduson belül a szam változó értéke ebben a hívásban 6 lesz.
 */


/*
 * TÖBB PARAMÉTER
 * --------------
 *
 * Egy metódus több adatot is kaphat.
 *
 * A programban:
 *
 *     static int VeletlenSzam(Random random, int minimum, int maximum)
 *
 * három paraméter található:
 *
 *     Random random
 *     int minimum
 *     int maximum
 *
 * Ezeket vessző választja el egymástól.
 *
 * A meghívás:
 *
 *     VeletlenSzam(random, 1, 11)
 *
 * Itt a három argumentum sorrendben bekerül a három paraméterbe:
 *
 *     random  -> random
 *     1       -> minimum
 *     11      -> maximum
 *
 * Ezután a metóduson belül:
 *
 *     random.Next(minimum, maximum)
 *
 * valójában ugyanúgy működik, mintha ezt írtuk volna:
 *
 *     random.Next(1, 11)
 *
 * A Next() felső határa kizárólagos, ezért az eredmény 1 és 10
 * közötti egész szám lehet.
 */


/*
 * static – MIT JELENT ITT?
 * ------------------------
 *
 * A Main fejlécében ezt már a legelső C# program óta látjuk:
 *
 *     static void Main(string[] args)
 *
 * Most azért válik igazán fontossá, mert saját metódusokat készítünk.
 *
 * Egy static metódus az osztályhoz tartozik, nem egy konkrét
 * létrehozott objektumhoz.
 *
 * Ezért a static Main-ből egy másik static metódust egyszerűen
 * meghívhatunk:
 *
 *     EgyszeruMetodus();
 *     SzamoljOtosig();
 *     Negyzet(6);
 *
 * Nem kell előtte Program objektumot létrehoznunk.
 *
 * Kezdő konzolos programoknál emiatt gyakran static metódusokkal
 * találkozunk először.
 */


/*
 * NEM static METÓDUS
 * ------------------
 *
 * A program végén ez szerepel:
 *
 *     void NemStatikusMetodus()
 *     {
 *         Console.WriteLine("Most a NemStatikusMetodus() fut.");
 *     }
 *
 * Nincs előtte static.
 *
 * Ezért ez a metódus egy Program PÉLDÁNYHOZ, vagyis egy létrehozott
 * Program objektumhoz tartozik.
 *
 * A Main viszont static, ezért innen nem írhatjuk egyszerűen ezt:
 *
 *     NemStatikusMetodus();
 *
 * Ehhez előbb létrehozunk egy Program objektumot:
 *
 *     Program program = new Program();
 *
 * majd azon keresztül hívjuk a metódust:
 *
 *     program.NemStatikusMetodus();
 *
 * A felépítés ismerős lehet a Random témából:
 *
 *     Random random = new Random();
 *     random.Next(...);
 *
 * Ott is létrehoztunk egy objektumot, majd azon hívtunk meg egy
 * nem static metódust.
 *
 * Ezen a ponton ennél mélyebben még nem szükséges belemenni az
 * objektumok és példányok működésébe. Később, az osztályoknál
 * ez sokkal részletesebben elő fog kerülni.
 */


/*
 * static ÉS NEM static – EGYMÁS MELLETT
 * -------------------------------------
 *
 * static metódus:
 *
 *     static void EgyszeruMetodus()
 *
 * Meghívása a static Main-ből:
 *
 *     EgyszeruMetodus();
 *
 *
 * nem static metódus:
 *
 *     void NemStatikusMetodus()
 *
 * Meghívása a static Main-ből:
 *
 *     Program program = new Program();
 *     program.NemStatikusMetodus();
 *
 * Kezdőként tehát a legfontosabb gyakorlati különbség:
 *
 *     static      -> itt közvetlenül meghívható
 *     nem static  -> példányon/objektumon keresztül hívjuk
 */


/*
 * METÓDUS ÉS for CIKLUS
 * ----------------------
 *
 * Egy metódus törzsében ugyanazokat a nyelvi elemeket használhatjuk,
 * amelyeket már a Main-ben is használtunk.
 *
 * Például lehet benne for ciklus:
 *
 *     static void SzamoljOtosig()
 *     {
 *         for (int i = 1; i <= 5; i++)
 *         {
 *             Console.Write($"{i} ");
 *         }
 *     }
 *
 * A for működése semmit nem változik attól, hogy külön metódusba került.
 *
 * A metódus egyszerűen egy névvel ellátott kódblokk, amelyben
 * ugyanúgy lehet:
 *
 *     - változó;
 *     - if;
 *     - switch;
 *     - for;
 *     - Random használat;
 *     - Console.WriteLine();
 *     - másik metódus meghívása;
 *
 * és később sok minden más is.
 */


/*
 * METÓDUS ÉS Random
 * ------------------
 *
 * A Main-ben egyszer létrehozzuk:
 *
 *     Random random = new Random();
 *
 * Ezután ezt az objektumot átadjuk a saját metódusunknak:
 *
 *     int veletlen = VeletlenSzam(random, 1, 11);
 *
 * A metódus:
 *
 *     static int VeletlenSzam(Random random, int minimum, int maximum)
 *     {
 *         int szam = random.Next(minimum, maximum);
 *         return szam;
 *     }
 *
 * Ebben egyszerre több korábbi ismeret kapcsolódik össze:
 *
 *     - Random objektum;
 *     - Next();
 *     - paraméterek;
 *     - int típus;
 *     - helyi változó;
 *     - return;
 *     - visszatérési érték.
 *
 * Fontos, hogy itt sem készítünk minden hívásnál új Random objektumot.
 * A Main-ben létrehozott egyetlen objektumot adjuk tovább a metódusnak.
 */


/*
 * A METÓDUSOK HELYE A Program OSZTÁLYBAN
 * --------------------------------------
 *
 * Ebben a tananyagban a saját metódusainkat a Program osztályon belül,
 * de a Main metóduson KÍVÜL hozzuk létre:
 *
 *     internal class Program
 *     {
 *         static void Main(string[] args)
 *         {
 *             EgyszeruMetodus();
 *         }
 *
 *         static void EgyszeruMetodus()
 *         {
 *             Console.WriteLine("Hello!");
 *         }
 *     }
 *
 * Vagyis a kapcsos zárójelek szintje nagyon fontos.
 *
 * A saját metódusunk:
 *
 *     - nincs a Main { } blokkján belül;
 *     - viszont még mindig a Program osztály { } blokkján belül van.
 *
 * A C# egyébként ismer úgynevezett helyi METÓDUSeket is, amelyeket
 * másik metódus belsejében lehet létrehozni, de EZ MOST NEM TÉMÁNK.
 * Az első lépésben maradunk a Program osztály közvetlen metódusainál.
 */


/*
 * A METÓDUSOK SORRENDJE A FÁJLBAN
 * -------------------------------
 *
 * A programban előbb található a Main, és csak alatta vannak a saját
 * metódusaink:
 *
 *     Main(...)
 *     EgyszeruMetodus()
 *     SzamoljOtosig()
 *     Negyzet(...)
 *     VeletlenSzam(...)
 *     NemStatikusMetodus()
 *
 * Ettől a Main még nyugodtan meghívhatja őket.
 *
 * A C# fordító nem úgy olvassa a fájlt, mint mi egy receptet, hogy
 * csak azt ismerheti, ami már korábban szerepelt a szövegben.
 * A Program osztály metódusait a fordítás során együtt kezeli.
 *
 * Ezért teljesen természetes, hogy a Main-ben ezt látjuk:
 *
 *     EgyszeruMetodus();
 *
 * miközben maga az EgyszeruMetodus() deklarációja csak néhány sorral
 * később található.
 */


/*
 * HATÓKÖR A METÓDUSOKBAN
 * ----------------------
 *
 * A metódusban létrehozott helyi változók csak az adott metódus
 * megfelelő blokkjában használhatók.
 *
 * Például:
 *
 *     static int Negyzet(int szam)
 *     {
 *         int eredmeny = szam * szam;
 *         return eredmeny;
 *     }
 *
 * Az eredmeny változó a Negyzet() helyi változója.
 *
 * A Main-ben nem írhatnánk ezt:
 *
 *     Console.WriteLine(eredmeny);
 *
 * mert ott az eredmeny változó nem létezik.
 *
 * A visszaadott ÉRTÉKET viszont átvehetjük egy másik változóba:
 *
 *     int negyzet = Negyzet(6);
 *
 * Itt a negyzet már a Main saját helyi változója.
 */


/*
 * A METÓDUS NEVE
 * ---------------
 *
 * A metódusnak érdemes olyan nevet adni, amelyből kiderül, mit csinál.
 *
 * Példák:
 *
 *     Negyzet()
 *     VeletlenSzam()
 *     SzamoljOtosig()
 *
 * kevésbé jó nevek lennének:
 *
 *     Metodus1()
 *     Valami()
 *     X()
 *
 * C#-ban a metódusneveknél a szokásos elnevezési forma a PascalCase:
 * minden szó nagy kezdőbetűvel indul.
 *
 * Például:
 *
 *     SzamoljOtosig
 *     VeletlenSzam
 *     KeruletSzamitas
 *
 * A fordító nem azért fogadja el ezeket, mert PascalCase alakúak;
 * ez elsősorban elnevezési szokás, amely olvashatóbbá teszi a kódot.
 */


/*
 * NÉGY EGYSZERŰ ESET, AMIT MOST FEL KELL ISMERNI
 * ---------------------------------------------
 *
 * 1. static + void
 *
 *     static void EgyszeruMetodus()
 *
 *     -> példány nélkül hívható
 *     -> nem ad vissza értéket
 *
 *
 * 2. static + nem void
 *
 *     static int Negyzet(int szam)
 *
 *     -> példány nélkül hívható
 *     -> int értéket ad vissza
 *
 *
 * 3. nem static + void
 *
 *     void NemStatikusMetodus()
 *
 *     -> Program objektumon keresztül hívjuk
 *     -> nem ad vissza értéket
 *
 *
 * 4. nem static + nem void
 *
 *     Ilyet ez az első példa szándékosan nem használ.
 *
 *     Természetesen ilyen is létezik, például:
 *
 *         int ValamilyenSzamitas()
 *
 *     de az első órán fontosabb a static/nem static és a
 *     void/visszatérési típus alapötletének megértése, mint az összes
 *     kombináció külön kipróbálása.
 */


/*
 * A PROGRAM FUTÁSA LÉPÉSEKBEN
 * ---------------------------
 *
 * A program indulásakor a Main() fut.
 *
 * 1. Kiírjuk:
 *
 *        A program elindult.
 *
 * 2. Meghívjuk:
 *
 *        EgyszeruMetodus();
 *
 *    A program átmegy a metódusba, kiírja a szöveget, majd visszatér.
 *
 * 3. Meghívjuk:
 *
 *        SzamoljOtosig();
 *
 *    A metódusban lefut a for ciklus.
 *
 * 4. Meghívjuk:
 *
 *        Negyzet(6)
 *
 *    A metódus 36-ot ad vissza, amely bekerül a negyzet változóba.
 *
 * 5. Létrehozunk egy Random objektumot, majd meghívjuk:
 *
 *        VeletlenSzam(random, 1, 11)
 *
 *    A metódus visszaad egy 1 és 10 közötti egész számot.
 *
 * 6. Létrehozunk egy Program objektumot:
 *
 *        Program program = new Program();
 *
 *    majd azon keresztül meghívjuk:
 *
 *        program.NemStatikusMetodus();
 *
 * 7. A program visszatér a Main végére és befejeződik.
 */


/*
 * A LEGFONTOSABB ÚJ FOGALMAK RÖVIDEN
 * ----------------------------------
 *
 * METÓDUS
 *     Névvel ellátott kódrészlet, amelyet meg lehet hívni.
 *
 * MEGHÍVÁS
 *     A metódus futtatása, például:
 *
 *         EgyszeruMetodus();
 *
 * void
 *     A metódus nem ad vissza értéket.
 *
 * VISSZATÉRÉSI TÍPUS
 *     Megmondja, milyen típusú értéket ad vissza a metódus.
 *     Például az int azt jelenti, hogy egész számot ad vissza.
 *
 * return
 *     Visszaad egy értéket a hívó kódrésznek.
 *
 * PARAMÉTER
 *     A metódus deklarációjában megadott bemenő változó.
 *
 * ARGUMENTUM
 *     A meghíváskor ténylegesen átadott érték.
 *
 * static
 *     A metódus az osztályhoz tartozik, és itt példány nélkül hívható.
 *
 * nem static
 *     A metódust egy létrehozott objektumon/példányon keresztül hívjuk.
 */


/*
 * MIT ÉRDEMES EBBŐL ELSŐRE TUDNI?
 * -------------------------------
 *
 * Első körben nem az a cél, hogy a C# metódusainak minden lehetőségét
 * ismerjük.
 *
 * Ha ezt a néhány dolgot biztosan felismerjük, már jó alapunk van:
 *
 *     1. A metódus egy külön névvel ellátott kódrészlet.
 *
 *     2. A metódust a neve és a () segítségével hívjuk meg:
 *
 *            EgyszeruMetodus();
 *
 *     3. A void azt jelenti, hogy nincs visszaadott érték.
 *
 *     4. Az int, double, string stb. a void helyén azt jelenti,
 *        hogy a metódus ilyen típusú értéket ad vissza.
 *
 *     5. Az értéket a return adhatja vissza.
 *
 *     6. A zárójelben paramétereket adhatunk meg:
 *
 *            Negyzet(int szam)
 *
 *     7. A static metódust a static Main-ből közvetlenül meghívhatjuk.
 *
 *     8. A nem static metódushoz ebben a példában Program objektumot
 *        hoztunk létre.
 *
 *     9. Egy metódusban ugyanúgy használhatjuk a korábban tanult
 *        elemeket, például for ciklust és Random objektumot.
 *
 * Ezekre később lehet építeni a bonyolultabb témákat: többféle
 * visszatérési érték, összetettebb paraméterezés, túlterhelés,
 * rekurzió, osztályok és objektumorientált programozás.
 * Ezeket azonban ennél az első METÓDUSes anyagnál még nem szükséges
 * egyszerre a diákokra zúdítani.
 */

namespace _09_Metodusek
{
    internal class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("A program elindult.\n");

            EgyszeruMetodus();

            SzamoljOtosig();

            int negyzet = Negyzet(6);
            Console.WriteLine($"6 négyzete: {negyzet}\n");

            Random random = new Random();
            int veletlen = VeletlenSzam(random, 1, 11);
            Console.WriteLine($"A METÓDUS által generált véletlen szám 1 és 10 között: {veletlen}\n");

            Program program = new Program();
            program.NemStatikusMetodus();

            Console.WriteLine("\nA program visszaért a Main végére.");
        }

        static void EgyszeruMetodus()
        {
            Console.WriteLine("Most az EgyszeruMetodus() fut.\n");
        }

        static void SzamoljOtosig()
        {
            Console.WriteLine("Most a SzamoljOtosig() fut:");

            for (int i = 1; i <= 5; i++)
            {
                Console.Write($"{i} ");
            }

            Console.WriteLine("\n");
        }

        static int Negyzet(int szam)
        {
            int eredmeny = szam * szam;
            return eredmeny;
        }

        static int VeletlenSzam(Random random, int minimum, int maximum)
        {
            int szam = random.Next(minimum, maximum);
            return szam;
        }

        void NemStatikusMetodus()
        {
            Console.WriteLine("Most a NemStatikusMetodus() fut.");
        }
    }
}