Segítség kérés c# class (osztályok)

Ez a téma lezárásra került a moderátor által. A lezárás oka: Témacím… témacím… témacím…
Címkék
Segítség kérés c# class (osztályok)
2021-02-25T10:05:52+01:00
2021-02-25T11:24:45+01:00
2022-12-06T17:55:34+01:00
FRETENSIS
sziasztok! Segítséget szeretnék kérni! Egy kis magyarázatra lenne szükségem c#-ban classok(osztályok) témában! Kicsit nehezen értem meg ezért úgymond bolond biztosan, ha lehetne valaki elmagyarázná nekem?  Az alábbi kódok szerint tenném fel a kérdéseket: a kivastagított részeket nem értem sajnos

a static void -nál a "Haromszog h ="  deklarációt nem teljesen értem most ugye itt miért kell "h"  betű vagy változó? ezt sem teljesen értem és ugye utána inicializálva van a Haromszog! A Haromszog és a h betű az most akkor a változót jelenti ? 


Kiíratásnál pedig a {0} az mit jelent? 

a class Haromszog-nél pedig a kivastagított részeket nem értem: rögtön az elején a három változó deklarálását nem értem, hogy most hogyan kapcsolódik a programhoz! 


If -eknél a feltételek és a this parancsra kaphatnék magyarázatot ? miért kell this és miért kell megadni a "<=" feltételeket 

elnézést , ha nagyon érthetetlen vagyok vagy annak tűnök. De ez nem jön át nekem. Örülnék ha valaki teljesen leírná nekem az osztályok lényegét erre a kis progira levetítve.  

Köszönöm a segítséget 




class Program

    {

        static void Main(string[] args)

        {

            Haromszog h = new Haromszog(3,4,5);

 

            Console.WriteLine("Terület: {0}", h.Terulet());

            Console.WriteLine("Kerulet: {0}", h.Kerulet());

            Console.WriteLine();

            Console.ReadKey();

        }

    }

..........................................................itt lent a külön fájlban megadott osztály a kritériumokkal..................................
...............................................................................................................................................................................................................
class Haromszog

    {

        double a;

        double b;

        double c;

 

        public Haromszog(double a, double b, double c)

        {

 

            if (a <= 0)

            {

                this.a = 1;

            }

 

            else

            {

                this.a = a;

            }

            if (b <= 0)

 

            {

                this.b = 1;

            }

            else

            {

                this.b = b;

            }

 

            if (c <= 0)

            {

                this.c = 1;

            }

            else

            {

                this.c = c;

            }

 

            
        }

        /// <summary>

        /// A háromszög területétszámoló metódus

        /// </summary>

        /// <returns>a háromszög területe</returns>

        public double Terulet()

        {

            double s = (a + b + c) / 2;

 

            return Math.Sqrt(s * (s - a) * (s - b) * (s - c));

        }

 

        public double Kerulet()

        {

            return a + b + c;

        }

    }
Mutasd a teljes hozzászólást!
miért kell "h"  betű vagy változó?

A programozási nyelvek szigorú szabályrendszerre épülnek. Azért kell, mert a deklaratív utasítás megköveteli. Maga a szintaktika így néz ki ebben az esetben:

típus azonosító = kifejezés;
A te példádban:

Haromszog h = new Haromszog(3,4,5);
Vagyis a változód típusa Haromszog, a neve h, az értéke pedig a "new Haromszog(3,4,5)" kifejezés értéke.

Az azonosító egyértelmű, miért kell, hiszen ezen a néven fogsz hivatkozni a későbbiekben a változódra. A kifejezésre is van egy megszorítás, mégpedig az, hogy olyan típusúnak kell lennie (vagy implicit cast-olhatónak), mint amilyen típusú a változód.

Ahhoz, hogy megértsd, hogy áll ez az egész össze, inkább elmondom röviden, miről szól ez az egész objektum-orientált programozás. Ennek valójában két fajtája van, az osztály alapú OOP (amit te használsz C# nyelvben), és a prototípus alapú (a JavaScript és a Lua nyelv a példa rá).

Az osztály alapú OOP két nagyon fontos alapfogalomra épül: az osztály és az objektum. Biztos észrevetted ebben a példában is (meg úgy minden más programnál), hogy a mi világunk tárgyaira, élőlényeire, fogalmaira és jelenségeire épít. Jelen példában a te programod a háromszögekkel foglalkozik. Amikor objektumorientáltan fejlesztünk, érdemes úgy gondolkodni, mintha a programod egy miniatűr világ lenne, ami teljesen üres. Azt szeretnénk, hogy ebben a kis világban a mi világunk egy miniatürizált változata működjön, tehát modelleznünk kell. Első lépésben a mi világunkból ki kell válogatni azokat a tárgyakat, élőlényeket, fogalmakat és jelenségeket, amelyek a programunk szempontjából fontosak. Jelen példában ez a háromszög. De gyakran ezeknek a dolgoknak is sok olyan tulajdonsága van, amely a szoftverünk számára fontos, míg más tulajdonságok nem, tehát ez lesz a szűrésünk második lépése. Mondjuk, ha veszünk egy olyan csodálatos rendszert, mint az e-napló az iskolában, fontos lesz a diák, és tudnunk kell a diák nevét, a lakcímét, de egy diáknak van sok olyan tulajdonsága is, ami minket nem érdekel, például a haja színe.

A végső célunk az, hogy azok a fogalmak, amik fontosak a szoftver szempontjából, megjelenjenek a program kis világában, azokkal a tulajdonságokkal és viselkedésekkel, amelyekre a szoftvernek szüksége van. Ezt hívjuk modellezésnek, és ennek az eszköze lesz az osztály. Ezzel írjuk le ugyanis azt, hogy a programunk világában milyen dolgok létezhetnek, és azoknak a dolgoknak milyen tulajdonságai és viselkedései vannak. Véve a példádat a háromszöggel:

class Haromszog { //a háromszög tulajdonságai double a; double b; double c; //konstruktor public Haromszog(double a, double b, double c) {...} //a háromszög viselkedései double Terulet() {...} double Kerulet() {...} }

(Nyilván lehet vitatkozni, hogy a terület és a kerület valójában a háromszög tulajdonsága-e vagy sem, ezt most tegyük félre.)
Az osztály tulajdonságait nevezzük mezőnek (field), a viselkedéseit (amik valójában függvények és eljárások) metódusnak. De ezt eddig úgy képzeld el, mint egy papírra vetett tervet. Ez nem a tényleges használható háromszög, csupán egy leírás arról, hogy a program világában egy háromszögnek mit kell tudnia.

Ezt a tervet felhasználva hozhatunk létre tényleges, használható objektumokat. Mint a való életben, egy terv alapján több, kézzel fogható és használható példányt csinálhatunk. Emiatt lesz fontos az is, hogy az osztály, mint típus, megjelenik a nyelvben. Tehát ha te csinálsz egy háromszög osztályt, innentől kezdve lehetőséged van arra, hogy háromszög típusú változókat hozz létre és háromszög típusú kifejezéseket írj. Egy objektum abban különbözik az osztálytól, hogy van úgynevezett állapota (vagyis a tulajdonságok most már felvehetnek értékeket), ami azt jelenti, hogy az osztályban leírt tulajdonságoknak pillanatnyilag milyen értékei vannak.

Ahhoz, hogy az osztályból objektum legyen, példányosításra van szükség. Ez az a "gyártási folyamat", amely során a tervből elkészül a tényleges, használható dolog. Ezt a "gyártási folyamatot" a konstruktor írja le. A konstruktor nem más, mint egy speciális metódus, amelynek a fő feladatai:
1) Lefoglalja a memóriát az objektum számára.
2) Kezdőállapotba hozza az objektumot.
3) Visszaadja a referenciáját az objektumnak (hol jött létre a memóriában).
Ebből fejlesztőként csak a második lépést látjuk, az a feladatunk, hogy ezt jól megírjuk. A kezdőállapot azt jelenti, hogy az objektum közvetlenül a létrehozása után milyen állapotban van.
A példányosítás a new kulcsszóval történik. Ez egy olyan típusú kifejezés lesz, amilyen osztályt példányosítasz. Ebben az esetben:

new Haromszog(3,4,5)
Ez a példányosítás egy Haromszog típusú kifejezés, amelyet többek között értékül adhatsz egy Haromszog típusú változónak:

Haromszog h = new Haromszog(3,4,5);
Egy osztálynak mindig van konstruktora, még akkor is, ha te magad nem írsz az osztályba ilyet (hála egy öröklődésnek hívott fogalomnak, amire most nem térek ki). Ha te nem írtál volna konstruktort a háromszög osztályodba, akkor így kellene példányosítanod. Továbbra is van konstruktora, csak épp nincs paramétere:

new Haromszog()

Kérdezted, hogy miért kellenek azok az ellenőrzések a konstruktorba. Azért, mert lehetőséged van arra, hogy ellenőrizd a paraméterek értékét, amit átadtak neki. Nem nagyon láttunk olyat, hogy egy háromszögnek az egyik oldala 0 vagy negatív hosszúságú lett volna. Erre egy példa:

new Haromszog(-5, 0, -9.6); //ilyen háromszög nincs
Ebben az esetben - a hülyeséget kivédvén - két lehetőségünk van:
1) egyszerűen csak azt mondjuk, hogy akkor ez legyen egy A=1, B=1, C=1 háromszög (egyébként ez is hülyeség, de mindegy)
2) kivételt dobunk (de ehhez még nem értünk)

Vesézzük ki a "this" kérdést. Nagyon-nagyon-nagyon egyszerűen megfogva a dolgot, amikor írod az osztályt (vagyis "tervezési időben" vagy), akkor valahogyan hivatkoznod kell önmagára. Ez egy olyan speciális objektum, amely lehetővé teszi azt, hogy az osztályon belül hivatkozz az osztályban leírt példányszintű tulajdonságokra és viselkedésekre (minden olyan tagra, amihez nem lett odaírva, hogy "static"). Nem használhatod "static" kulcsszóval jelölt metódusokban, mivel azok nem példányszintűek, hanem osztályszintűek - még egy téma, amire most nem térek ki.

Kérdezted még a Console.WriteLine metódust is, hogy miért kell oda a "{0}". Alapesetben, ha ki akarunk íratni valamit, akkor azt így tehetjük meg:

Console.WriteLine("A háromszög kerülete: " + h.Kerulet().ToString());
Ez két szöveget fűz össze a + operátor miatt. Ezen lehet egyszerűsíteni a .ToString() elhagyásával, aminek az oka némi mágia, amiről még nem tudsz:

Console.WriteLine("A háromszög kerülete: " + h.Kerulet());
Ha kényelmetlen neked a + operátor használata, csinálhatod ezt is:

Console.WriteLine("A háromszög kerülete: {0}", h.Kerulet());
Egy még modernebb változata az ún. string interpoláció:

Console.WriteLine($"A háromszög kerülete: {h.Kerulet()}");

Ennek így nyilván nem látod az értelmét, de mondjuk ha nem csak egy, hanem több adatot kell összefűznöd, vagy nem csak változóid, hanem összetettebb kifejezéseid vannak, a kódodban a szöveg hamar átláthatatlanná válhat. Ennek elkerülésére lett ez kitalálva:

int i = 5, j = 6, eredmeny = i+j; Console.Writeline("{0} + {1} = {2}", i, j, eredmeny); //az i kerül a {0} helyére, j az {1} helyére és eredmeny a {2} helyére
Mutasd a teljes hozzászólást!

  • class Haromszog { double a; double b; double c; public Haromszog(double a, double b, double c) { //Az osztály tagváltozóinak és a paraméter változók nevei egyezőek (a,b,c). //A this előtaggal jelzed, hogy a tagváltozóba akarod tenni a paraméter változóban szereplő értéket. //Hátha ez segít: https://csharptutorial.hu/docs/hellovilag-hellocsharp/5-osztalyok-objektumok/metodusok-konstruktor-peldanyositas/#a-this-kulcsszo-hasznalata //'<=' relációval ellenőrzöd, hogy az 'a' paraméter változó értéke negatív, vagy nulla-e. //Ha igen, akkor a tagváltozó (itt az 'a') értéke 1 lesz. if (a <= 0) { this.a = 1; } else { this.a = a; } if (b <= 0) { this.b = 1; } else { this.b = b; } if (c <= 0) { this.c = 1; } else { this.c = c; } } public double Terulet() { double s = (a + b + c) / 2; return Math.Sqrt(s * (s - a) * (s - b) * (s - c)); } public double Kerulet() { return a + b + c; } } class Program { static void Main(string[] args) { //A h a Haromszög osztályból származtatott egyed azonosítója. //Ezen az azonosítón keresztül tudsz hivatkozni rá. //A deklarálás és az inicializálás két lépésben is történhet(ne). //Az elsőben deklarálsz egy változót (már akkor meg kell határoznod a típusát): Haromszög h; //Másodikban valamilyen - most Haromszög - típusú egyedet/példányt rendelsz hozzá: h = new Haromszog(3,4,5) Haromszog h = new Haromszog(3, 4, 5); //A vessző után több 'értéket' is fel tudsz sorolni. Ezeknek a sorrendje egyben a sorszáma (indexe) is, //ami 0-ról indul. Az idézőjelen belül a {0} kifejezés a felsorolt értékeket jelképezi, azt helyettesíti be. //Ha Console.WriteLine("Terület: {0} {0} {0}", h.Terulet()); -t írsz, akkor háromszor helyettesíti be (írja ki) a terület értéket. //De kiírathatod így is: Console.WriteLine($"Terület: {h.Terulet()}"); //Ez a string interpolation: https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/tokens/interpolated Console.WriteLine("Terület: {0}", h.Terulet()); Console.WriteLine("Kerulet: {0}", h.Kerulet()); //Ugyanez másképpen: Console.WriteLine("A {2} területe: {0}, kerülete: {1}", h.Terulet(), h.Kerulet(), "háromszög"); Console.WriteLine(); Console.ReadKey(); } }
    this-hez rövid segítség: Metódusok – Konstruktor, példányosítás
    Mutasd a teljes hozzászólást!
  • miért kell "h"  betű vagy változó?

    A programozási nyelvek szigorú szabályrendszerre épülnek. Azért kell, mert a deklaratív utasítás megköveteli. Maga a szintaktika így néz ki ebben az esetben:

    típus azonosító = kifejezés;
    A te példádban:

    Haromszog h = new Haromszog(3,4,5);
    Vagyis a változód típusa Haromszog, a neve h, az értéke pedig a "new Haromszog(3,4,5)" kifejezés értéke.

    Az azonosító egyértelmű, miért kell, hiszen ezen a néven fogsz hivatkozni a későbbiekben a változódra. A kifejezésre is van egy megszorítás, mégpedig az, hogy olyan típusúnak kell lennie (vagy implicit cast-olhatónak), mint amilyen típusú a változód.

    Ahhoz, hogy megértsd, hogy áll ez az egész össze, inkább elmondom röviden, miről szól ez az egész objektum-orientált programozás. Ennek valójában két fajtája van, az osztály alapú OOP (amit te használsz C# nyelvben), és a prototípus alapú (a JavaScript és a Lua nyelv a példa rá).

    Az osztály alapú OOP két nagyon fontos alapfogalomra épül: az osztály és az objektum. Biztos észrevetted ebben a példában is (meg úgy minden más programnál), hogy a mi világunk tárgyaira, élőlényeire, fogalmaira és jelenségeire épít. Jelen példában a te programod a háromszögekkel foglalkozik. Amikor objektumorientáltan fejlesztünk, érdemes úgy gondolkodni, mintha a programod egy miniatűr világ lenne, ami teljesen üres. Azt szeretnénk, hogy ebben a kis világban a mi világunk egy miniatürizált változata működjön, tehát modelleznünk kell. Első lépésben a mi világunkból ki kell válogatni azokat a tárgyakat, élőlényeket, fogalmakat és jelenségeket, amelyek a programunk szempontjából fontosak. Jelen példában ez a háromszög. De gyakran ezeknek a dolgoknak is sok olyan tulajdonsága van, amely a szoftverünk számára fontos, míg más tulajdonságok nem, tehát ez lesz a szűrésünk második lépése. Mondjuk, ha veszünk egy olyan csodálatos rendszert, mint az e-napló az iskolában, fontos lesz a diák, és tudnunk kell a diák nevét, a lakcímét, de egy diáknak van sok olyan tulajdonsága is, ami minket nem érdekel, például a haja színe.

    A végső célunk az, hogy azok a fogalmak, amik fontosak a szoftver szempontjából, megjelenjenek a program kis világában, azokkal a tulajdonságokkal és viselkedésekkel, amelyekre a szoftvernek szüksége van. Ezt hívjuk modellezésnek, és ennek az eszköze lesz az osztály. Ezzel írjuk le ugyanis azt, hogy a programunk világában milyen dolgok létezhetnek, és azoknak a dolgoknak milyen tulajdonságai és viselkedései vannak. Véve a példádat a háromszöggel:

    class Haromszog { //a háromszög tulajdonságai double a; double b; double c; //konstruktor public Haromszog(double a, double b, double c) {...} //a háromszög viselkedései double Terulet() {...} double Kerulet() {...} }

    (Nyilván lehet vitatkozni, hogy a terület és a kerület valójában a háromszög tulajdonsága-e vagy sem, ezt most tegyük félre.)
    Az osztály tulajdonságait nevezzük mezőnek (field), a viselkedéseit (amik valójában függvények és eljárások) metódusnak. De ezt eddig úgy képzeld el, mint egy papírra vetett tervet. Ez nem a tényleges használható háromszög, csupán egy leírás arról, hogy a program világában egy háromszögnek mit kell tudnia.

    Ezt a tervet felhasználva hozhatunk létre tényleges, használható objektumokat. Mint a való életben, egy terv alapján több, kézzel fogható és használható példányt csinálhatunk. Emiatt lesz fontos az is, hogy az osztály, mint típus, megjelenik a nyelvben. Tehát ha te csinálsz egy háromszög osztályt, innentől kezdve lehetőséged van arra, hogy háromszög típusú változókat hozz létre és háromszög típusú kifejezéseket írj. Egy objektum abban különbözik az osztálytól, hogy van úgynevezett állapota (vagyis a tulajdonságok most már felvehetnek értékeket), ami azt jelenti, hogy az osztályban leírt tulajdonságoknak pillanatnyilag milyen értékei vannak.

    Ahhoz, hogy az osztályból objektum legyen, példányosításra van szükség. Ez az a "gyártási folyamat", amely során a tervből elkészül a tényleges, használható dolog. Ezt a "gyártási folyamatot" a konstruktor írja le. A konstruktor nem más, mint egy speciális metódus, amelynek a fő feladatai:
    1) Lefoglalja a memóriát az objektum számára.
    2) Kezdőállapotba hozza az objektumot.
    3) Visszaadja a referenciáját az objektumnak (hol jött létre a memóriában).
    Ebből fejlesztőként csak a második lépést látjuk, az a feladatunk, hogy ezt jól megírjuk. A kezdőállapot azt jelenti, hogy az objektum közvetlenül a létrehozása után milyen állapotban van.
    A példányosítás a new kulcsszóval történik. Ez egy olyan típusú kifejezés lesz, amilyen osztályt példányosítasz. Ebben az esetben:

    new Haromszog(3,4,5)
    Ez a példányosítás egy Haromszog típusú kifejezés, amelyet többek között értékül adhatsz egy Haromszog típusú változónak:

    Haromszog h = new Haromszog(3,4,5);
    Egy osztálynak mindig van konstruktora, még akkor is, ha te magad nem írsz az osztályba ilyet (hála egy öröklődésnek hívott fogalomnak, amire most nem térek ki). Ha te nem írtál volna konstruktort a háromszög osztályodba, akkor így kellene példányosítanod. Továbbra is van konstruktora, csak épp nincs paramétere:

    new Haromszog()

    Kérdezted, hogy miért kellenek azok az ellenőrzések a konstruktorba. Azért, mert lehetőséged van arra, hogy ellenőrizd a paraméterek értékét, amit átadtak neki. Nem nagyon láttunk olyat, hogy egy háromszögnek az egyik oldala 0 vagy negatív hosszúságú lett volna. Erre egy példa:

    new Haromszog(-5, 0, -9.6); //ilyen háromszög nincs
    Ebben az esetben - a hülyeséget kivédvén - két lehetőségünk van:
    1) egyszerűen csak azt mondjuk, hogy akkor ez legyen egy A=1, B=1, C=1 háromszög (egyébként ez is hülyeség, de mindegy)
    2) kivételt dobunk (de ehhez még nem értünk)

    Vesézzük ki a "this" kérdést. Nagyon-nagyon-nagyon egyszerűen megfogva a dolgot, amikor írod az osztályt (vagyis "tervezési időben" vagy), akkor valahogyan hivatkoznod kell önmagára. Ez egy olyan speciális objektum, amely lehetővé teszi azt, hogy az osztályon belül hivatkozz az osztályban leírt példányszintű tulajdonságokra és viselkedésekre (minden olyan tagra, amihez nem lett odaírva, hogy "static"). Nem használhatod "static" kulcsszóval jelölt metódusokban, mivel azok nem példányszintűek, hanem osztályszintűek - még egy téma, amire most nem térek ki.

    Kérdezted még a Console.WriteLine metódust is, hogy miért kell oda a "{0}". Alapesetben, ha ki akarunk íratni valamit, akkor azt így tehetjük meg:

    Console.WriteLine("A háromszög kerülete: " + h.Kerulet().ToString());
    Ez két szöveget fűz össze a + operátor miatt. Ezen lehet egyszerűsíteni a .ToString() elhagyásával, aminek az oka némi mágia, amiről még nem tudsz:

    Console.WriteLine("A háromszög kerülete: " + h.Kerulet());
    Ha kényelmetlen neked a + operátor használata, csinálhatod ezt is:

    Console.WriteLine("A háromszög kerülete: {0}", h.Kerulet());
    Egy még modernebb változata az ún. string interpoláció:

    Console.WriteLine($"A háromszög kerülete: {h.Kerulet()}");

    Ennek így nyilván nem látod az értelmét, de mondjuk ha nem csak egy, hanem több adatot kell összefűznöd, vagy nem csak változóid, hanem összetettebb kifejezéseid vannak, a kódodban a szöveg hamar átláthatatlanná válhat. Ennek elkerülésére lett ez kitalálva:

    int i = 5, j = 6, eredmeny = i+j; Console.Writeline("{0} + {1} = {2}", i, j, eredmeny); //az i kerül a {0} helyére, j az {1} helyére és eredmeny a {2} helyére
    Mutasd a teljes hozzászólást!
Ez a téma lezárásra került a moderátor által. A lezárás oka: Témacím… témacím… témacím…
Címkék
Tetszett amit olvastál? Szeretnél a jövőben is értesülni a hasonló érdekességekről?
abcd