Brno? Vypsali jsme pro vás nové termíny školení OOP v Brně!

Lekce 2 - První objektová aplikace v Javě - Hello object world

Unicorn College Tento obsah je dostupný zdarma v rámci projektu IT lidem.
Vydávání, hosting a aktualizace umožňují jeho sponzoři.

Minulá lekce, Úvod do objektově orientovaného programování v Javě, nás uvedla do objektově orientovaného programování. Již víme, že objekty mají atributy a metody. Také víme, že k vytvoření objektu vytvoříme nejprve třídu. Ta je vzorem, podle kterého následně tvoříme její instance.

Na začátku kurzu se základními strukturami jazyka Javy jsme si vytvořili program Hello world. Udělejme si nyní podobný program jako úvod do objektově orientovaného programování. Naprogramujme si Hello object world!

Založme si v NetBeans novou Java aplikaci tak, jak jsme to dělali doposud. V Projects klikneme pravým tlačítkem myši na package našeho projektu a vybereme New -> Java Class.

Přidání nové třídy class k Java projektu v NetBeans

Class pojmenujeme Zdravic a potvrdíme. Název třídy píšeme vždy velbloudí notací bez mezer a na rozdíl od proměnných každé slovo má velké první písmeno, tedy i první. Název je samozřejmě také bez diakritiky, tu v programu používáme max. uvnitř textových řetězců, nikoli v identifikátorech.

Vytvoření nové třídy v Javě v NetBeans

Podle této třídy později vytvoříme objekt zdravič, který nás bude umět pozdravit. Vidíme, že se na program již díváme úplně jinak, za každou akci je zodpovědný nějaký objekt, nestačí pouze něco "nabušit" do main(). V našem případě vám to může přijít zbytečné, u složitějších aplikací si to budete pochvalovat :)

V našem package přibude další soubor .java a NetBeans nám ho otevře. K původnímu HelloObjects.java s metodou main() se můžeme vrátit pomocí záložky nebo přes záložku Projects.

Podívejme se, co nám NetBeans vygeneroval a kód si popišme. Následně si do třídy přidáme vlastní metodu pro pozdravení.

package helloobjects;

public class Zdravic {

}

package nám označuje tzv. balíček. Stejně jako se metody sdružují do tříd, tak se třídy sdružují do balíčků. Pokud chceme, aby byla naše třída viditelná i ve výchozí třídě, kde máme metodu main(), musíme ji mít ve stejném balíčku. To zde platí, NetBeans samo novou třídu vloží do toho samého balíčku, vy místo helloobjects budete mít název své aplikace, pokud jste ji nepojmenovali, bude tam javaapplication1.

V package je tedy umístěná samotná třída, která se deklaruje klíčovým slovem class. Třída se jmenuje Zdravic a je prázdná.

Všimněte si, že kód je téměř stejný, jako ten v HelloObjects.java, již tedy rozumíme tomu, co jsme předtím ignorovali. Náš konzolový program byla vlastně třída umístěná v package, která obsahovala jednu metodu main(). Vidíme, že v Javě se v podstatě neobjektově programovat ani nedá, což je jen dobře :)

Nyní si do třídy Zdravic přidáme metodu pozdrav(), bude veřejně viditelná a nebude mít žádnou návratovou hodnotu ani atributy.

Deklarace metody v Javě je tedy následující:

[modifikátor přístupu] [návratový typ] [jmenoMetody]([parametry])

Před metodou bude tzv. modifikátor přístupu, v našem případě public (veřejná). Metoda nebude vracet žádnou hodnotu, toho docílíme klíčovým slovem void. Dále bude následovat samotný název metody, metody píšeme stejně jako proměnné velbloudí notací s malým poč. písmenem. Závorka s parametry je povinná, my ji necháme prázdnou, protože metoda žádné parametry mít nebude. Do těla metody zapíšeme kód pro výpis na konzoli:

Naše třída bude nyní vypadat takto:

public class Zdravic {

    public void pozdrav() {
        System.out.println("Hello object world!");
    }

}

Zde jsme prozatím skončili, přejdeme do HelloObjects.java.

Nyní si v těle metody main() vytvoříme instanci třídy Zdravic. Bude to tedy ten objekt zdravič, se kterým budeme pracovat. Objekty se ukládají do proměnných, název třídy slouží jako datový typ. Instance má zpravidla název třídy, jen má první písmeno malé. Deklarujme si proměnnou a následně v ní založme novou instanci třídy Zdravic:

Zdravic zdravic;
zdravic = new Zdravic();

První řádek říká: "Chci proměnnou zdravic, ve které bude instance třídy Zdravic". S proměnnými jsme vlastně již takto pracovali.

Na druhém řádku je klíčové slovo new, které nám založí novou instanci třídy Zdravic. Tuto instanci přiřadíme do naší proměnné.

Při vytvoření nové instance se zavolá tzv. konstruktor. To je speciální metoda na třídě, proto při vytvoření instance píšeme ty prázdné závorky, jelikož voláme tuto "vytvářecí" metodu. Konstruktor zpravidla obsahuje nějakou inicializaci vnitřního stavu instance (např. dosadí výchozí hodnoty do proměnných). My jsme v kódu žádný konstruktor nedeklarovali, Java si proto vytvořila tzv. implicitní bezparametrický konstruktor. Vytvoření instance objektu je tedy podobné volání metody. Celý zápis můžeme samozřejmě zkrátit na:

Zdravic zdravic = new Zdravic();

Jelikož v proměnné nyní máme opravdu instanci třídy Zdravic, můžeme instanci nechat pozdravit. Zavoláme na ni metodu pozdrav a to jako zdravic.pozdrav(). Kód metody main() bude tedy nyní vypadat následovně:

    Zdravic zdravic = new Zdravic();
    zdravic.pozdrav();

Program spustíme.

Konzolová aplikace
Hello object world!

Máme tedy svou první objektovou aplikaci!

Dejme nyní naší metodě pozdrav() parametr jmeno, aby dokázala pozdravit konkrétního uživatele:

public void pozdrav(String jmeno) {
    System.out.printf("Ahoj uživateli %s\n", jmeno);
}

Vidíme, že syntaxe parametru metody je stejná, jako syntaxe proměnné. Kdybychom chtěli parametrů více, oddělujeme je čárkou. Upravíme nyní naši metodu main():

Zdravic zdravic = new Zdravic();
zdravic.pozdrav("Karel");
zdravic.pozdrav("Petr");

Náš kód je nyní v metodě a my ho můžeme jednoduše pomocí parametrů volat znovu s různými parametry. Nemusíme 2x opisovat "Ahoj uživateli...". Kód budeme odteď dělit logicky do metod.

Konzolová aplikace
Ahoj uživateli Karel
Ahoj uživateli Petr

Třídě přidáme nějaký atribut, nabízí se text, kde bude uložen text pozdravu. Atributy se definují stejně, jako proměnné. Jako u metod platí, že před ně píšeme modifikátor přístupu, bez něj je Java bere jako package-private, viz dále v kurzu. Upravme naši třídu:

public class Zdravic {
    public String text;

    public void pozdrav(String jmeno) {
        System.out.printf("%s %s\n", text, jmeno);
    }

}

Text nyní musíme pochopitelně nastavit vytvořené instanci v HelloObjects.java:

    Zdravic zdravic = new Zdravic();
    zdravic.text = "Ahoj uživateli";
    zdravic.pozdrav("Karel");
    zdravic.pozdrav("Petr");
    zdravic.text = "Vítám tě tu programátore";
    zdravic.pozdrav("Richard");

Výsledek:

Konzolová aplikace
Ahoj uživateli Karel
Ahoj uživateli Petr
Vítám tě tu programátore Richard

Vzhledem k objektovému návrhu není nejvhodnější, aby si každý objekt ovlivňoval vstup a výstup, jak se mu zachce. Pochopitelně narážím na naše vypisování do konzole. Každý objekt by měl mít určitou kompetenci a tu by neměl překračovat. Pověřme náš objekt pouze sestavením pozdravu a jeho výpis si zpracujeme již mimo, v našem případě v metodě main(). Výhodou takto navrženého objektu je vysoká univerzálnost a znovupoužitelnost. Objekt doposud umí jen psát do konzole, my ho však přizpůsobíme tak, aby daná metoda text pouze vracela a bylo na jeho příjemci, jak s ním naloží. Takto můžeme pozdravy ukládat do souborů, psát na webové stránky nebo dále zpracovávat.

Jelikož chceme, aby metoda vracela hodnotu a to String, změníme její dosavadní typ void na String. K návratu hodnoty použijeme příkaz return. Return metodu ukončí a navrátí hodnotu, jakýkoli kód v těle metody po return se již neprovede! Upravme obě třídy:

Metoda pozdrav v Zdravic.java:

public String pozdrav(String jmeno) {
    return String.format("%s %s", text, jmeno);
}

Tělo metody main() v HelloObjects.java:

    Zdravic zdravic = new Zdravic();
    zdravic.text = "Ahoj uživateli";
    System.out.println(zdravic.pozdrav("Karel"));
    System.out.println(zdravic.pozdrav("Petr"));
    zdravic.text = "Vítám tě tu programátore";
    System.out.println(zdravic.pozdrav("Richard"));

Nyní je náš kód dle dobrých praktik. Ještě naši třídu okomentujme, jak se sluší a patří. Komentáře budeme psát nad název třídy a nad název každého atributu a metody. K jejich zápisu použijeme "/** Popisek */". Vyplatí se nám to ve chvíli, když na třídě používáme nějakou metodu, její popis se nám zobrazí v našeptávači. Zdokumentovaná třída může vypadat např. takto:

/** Třída reprezentuje zdravič, který slouží ke zdravení uživatelů */
public class Zdravic {
    /** Text pozdravu */
    public String text;

    /**
     * Pozdraví uživatele textem pozdravu a jeho jménem
     * @param  jmeno  Jméno uživatele
     * @return      Text s pozdravem
     */
    public String pozdrav(String jmeno) {
        return String.format("%s %s", text, jmeno);
    }

}

/* */ je víceřádkový komentář, syntaxe popisků se nazývá Javadoc. NetBeans umí Javadoc sám přidat do vašeho kódu, stačí ho pak jen vyplnit. Kliknete pravým na třídu v záložce Project a zvolíte Tools -> Analyze Javadoc, zaškrtáte chybějící políčka a potvrdíte tlačítkem. Z Javadoc umí Netbeans i generovat dokumentaci ve formátu HTML. Pokud budete své třídy dobře popisovat, programátorskou dokumentaci k aplikaci vytvoříte poté jediným kliknutím.

Podíváme se, že nám NetBeans opravdu popisky zobrazí:

Metody objektu zdravic v NetBeans

A jsme u konce. Námi napsaný program má již nějakou úroveň, i když vlastně nic nedělá. Za úkol máte předělat si naši konzolovou kalkulačku do objektů. V příští lekci, Hrací kostka v Javě - konstruktory a náhodná čísla, si uděláme takovou jednoduchou hříčku, necháme dva objekty (bojovníky) soupeřit v aréně (také objektu). Máte se na co těšit ;-)


 

Stáhnout

Staženo 1485x (18.09 kB)
Aplikace je včetně zdrojových kódů v jazyce java

 

 

Článek pro vás napsal David Čápka
Avatar
Jak se ti líbí článek?
49 hlasů
Autor pracuje jako softwarový architekt a pedagog na projektu ITnetwork.cz (a jeho zahraničních verzích). Velmi si váží svobody podnikání v naší zemi a věří, že když se člověk neštítí práce, tak dokáže úplně cokoli.
Unicorn College Autor sítě se informační technologie naučil na Unicorn College - prestižní soukromé vysoké škole IT a ekonomie.
Předchozí článek
Úvod do objektově orientovaného programování v Javě
Všechny články v sekci
Objektově orientované programování v Javě
Miniatura
Následující článek
Cvičení k 2. lekci OOP v Javě
Aktivity (15)

 

 

Komentáře
Zobrazit starší komentáře (95)

Avatar
Karel Klíč
Člen
Avatar
Karel Klíč:15.12.2018 19:19

Divím se co jsem tu psal teď je mi jasné že každá třída class je jeden soubor tedy komponenta která obsahuje metody, teď už mi došlo, že co soubor tedy class respektive .java je tou výhodou a komponentou celého objektově orientovaného programování. To je přesně to paradigma.

 
Odpovědět 15.12.2018 19:19
Avatar
Tomas Gorcos
Člen
Avatar
Tomas Gorcos:12. února 13:47

Dobrý deň. Chcem sa opýtať, kde by som našiel bližšie špecifikacie pre printf a všetky tie symboli, cisla a pismena. Ako a kde sa používajú?

 
Odpovědět 12. února 13:47
Avatar
patrik.valkovic
Šéfredaktor
Avatar
Odpovědět 12. února 13:48
Nikdy neumíme dost na to, abychom se nemohli něco nového naučit.
Avatar
Alesh
Člen
Avatar
Alesh:19. března 20:41

Mohl by mi někdo zkušený říct, jestli jsem se správně zhostil úkolu předělání kalkulačky do objektové varianty? Jakékoli konstruktivní připomínky vítány! ;-)

Pozn.: zaokrouhlovací chybu u floatu neřeším, zrovna tak jsem si odpustil ten cyklus na opětovné použití kalkulačky.

Jde mi čistě o tu "konstrukci", kde použít objekt a kde to nechat v rovině strukturovaného programování. A jestli to, jak jsem to napsal, vypadá jako kdyby to psal opravdový programátor. :-)

main:

package kalkulackaobject;

/**
 *
 * @author Aleš Bláha
 */
public class KalkulackaObject {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // inicializace kalkulacky
        Kalkulacka kalkulacka = new Kalkulacka();

        //uvitaci hlaska
        kalkulacka.vypisUvitani();

        do{
            kalkulacka.vypisVyzvuKZadaniHodnotyDoKonzole(1);
        }while(!kalkulacka.NactiAOtestujZadanouHodnotuZKonzole(1));

        do{
            kalkulacka.vypisVyzvuKZadaniHodnotyDoKonzole(2);
        }while(!kalkulacka.NactiAOtestujZadanouHodnotuZKonzole(2));

        do{
            kalkulacka.vypisVyzvuKZadaniOperatoraDoKonzole();
        }while(!kalkulacka.NactiAOtestujZadanehoOperatoraZKonzole());

        kalkulacka.VypoctiAVypisVysledekDoKonzole();

        //podekovani za pouziti
        kalkulacka.vypisPodekovani();
    }

}

kalkulačka:

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package kalkulackaobject;

import java.util.Scanner;

/**
 * trida Kalkulacka
 * @author Aleš Bláha
 */
public class Kalkulacka {
    /** prvni zadavane cislo */
    private float cislo1;

    /** druhe zadavane cislo */
    private float cislo2;

    /** symbol operace (+, -, *, /) */
    private Character operace;

    /** vypise uvitaci hlasku */
    public void vypisUvitani(){
        System.out.println("Vítejte v programu Kalkulačka!");
    }

    /** vypise dekovaci hlasku */
    public void vypisPodekovani(){
        System.out.println("Děkuji za použití kalkulačky.");
    }

    /**
     * vypise hlasku pro vlozeni prvni nebo druhe hodnoty
     * @param poradiHodnoty 1. nebo 2. zadavana hodnota (vlozit lze pouze 1 nebo 2)
     */
    public void vypisVyzvuKZadaniHodnotyDoKonzole(int poradiHodnoty){
        System.out.printf("Zadej %d. číslo: ", poradiHodnoty);
    }

    /**
     * z konzole nacte prvni nebo druhou vstupni hodnotu, ulozi do prislusne promenne
     * @param poradiHodnoty 1. nebo 2. zadavana hodnota (vlozit lze pouze 1 nebo 2)
     * @return info je hodnota v poradku
     */
    public boolean NactiAOtestujZadanouHodnotuZKonzole(int poradiHodnoty){
        try{
            Scanner sc = new Scanner(System.in, "Windows-1250");
            switch (poradiHodnoty) {
                case 1:
                    cislo1 = Float.parseFloat(sc.nextLine());
                    return true;
                case 2:
                    cislo2 = Float.parseFloat(sc.nextLine());
                    return true;
                default:
                    return false;
            }
        }
        catch(Exception e){
            return false;
        }
    }

    /** vypise hlasku pro vlozeni operatora (+, -, *, /) */
    public void vypisVyzvuKZadaniOperatoraDoKonzole(){
        System.out.print("Zadej operátora (+, -, *, /): ");
    }

    /**
     * z konzole nacte operatora (povolene operatory: +, -, *, /), ulozi do prislusne promenne
     * @return info je operator v poradku
     */
    public boolean NactiAOtestujZadanehoOperatoraZKonzole(){
        try{
            Scanner sc = new Scanner(System.in, "Windows-1250");
            operace = sc.nextLine().charAt(0);
            switch (operace) {
                case '+':
                case '-':
                case '*':
                case '/':
                    return true;
                default:
                    return false;
            }
        }
        catch(Exception e){
            return false;
        }
    }

    /**
     * vypocte a vypise vysledek do konzole
     */
    public void VypoctiAVypisVysledekDoKonzole(){
        float vysledek = 0;
        switch(operace){
            case '+':
                 vysledek = cislo1 + cislo2;
                 break;
            case '-':
                vysledek = cislo1 - cislo2;
                break;
            case '*':
                vysledek = cislo1 * cislo2;
                break;
            case '/':
                vysledek = (float) cislo1 / cislo2;
                break;
        }
        System.out.printf("%f %c %f = %f\n", cislo1, operace, cislo2, vysledek);
    }
}
 
Odpovědět 19. března 20:41
Avatar
Wopat
Člen
Avatar
Wopat:5. dubna 17:19

V lekci je uvedeno, že při vytvoření nové třídy NetBeans automaticky vygeneruje následující kód:

package helloobjects;

public class Zdravic {

}

U mě je však třída úplně prázdná. Zkoušel jsem hledat v nastavení IDE i na internetu, ale bohužel bez úspěchu. Nevíte někdo, kde je problém, prosím?

Odpovědět 5. dubna 17:19
The difficult we do immediately. The impossible takes a little longer.
Avatar
Danny Holys
Člen
Avatar
Danny Holys:23. července 12:50

Chtěl bych se zeptat místních veteránů, zda jsem tu kalkulačku v objektech napsal dobře, nebo spíše tedy, jestli se tam nedá něco zlepšit z ohledu OOP. díky moc :)

hlavní main:

package kalkulacka_objekt;
import java.util.Scanner;

/**
 *
 * @author Danie
 */
public class Kalkulacka_objekt {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        Kalkulator kalkulator = new Kalkulator();
        Scanner sc = new Scanner(System.in, "Windows-1250");
        kalkulator.pokracovat = "ano";
        float vysledek =0;
        System.out.println("Vítejte v kalkulačce");

        while(kalkulator.pokracovat.equals("ano")){
            System.out.println("Zadejte první číslo");
            float a = Float.parseFloat(sc.nextLine());
            System.out.println("Zadejte druhé číslo:");
            float b = Float.parseFloat(sc.nextLine());
            System.out.println("Zvolte si operaci:");
            System.out.println("1 - sčítání");
            System.out.println("2 - odčítání");
            System.out.println("3 - násobení");
            System.out.println("4 - dělení");
            int volba = Integer.parseInt(sc.nextLine());
            System.out.println(kalkulator.proces(volba, a, b, vysledek));
            System.out.println("Přejete si pokračovat?");
            kalkulator.pokracovat = sc.nextLine();
        }
        System.out.println("Děkuji za využití kalkulačky");
    }

}

Třída Kalkulator:

package kalkulacka_objekt;

/**
 *
 * @author Danie
 */
public class Kalkulator {
    public String pokracovat;

    public String proces(int volba, float a, float b, float vysledek){
        if (volba == 1)
        {
           vysledek = a + b;
        }
        else if (volba == 2)
        {
           vysledek = a - b;
        }
        else if (volba == 3)
        {
           vysledek = a * b;
        }
        else if (volba == 4)
        {
           vysledek = a / b;
        }
        if ((volba > 0) && (volba < 5))
        {
          return String.format("Výsledek: " + Float.toString(vysledek));
        }
        else
        {
           return String.format("Neplatná volba");
        }

    }
}
 
Odpovědět 23. července 12:50
Avatar
Odpovídá na Danny Holys
Michal Šmahel:24. července 18:27

Ahoj, jsem moc rád, že se zajímáš o kvalitu svého kódu a nebojíš se zde zeptat. Jako začátečník děláš různé zbytečné chyby (i vážnějšího charakteru) a je dobré o nich vědět, aby ses jim příště mohl vyvarovat. Neber to prosím jako kritiku, ale spíše jako doporučení. Když jsem začínal, dělal jsem také podobné věci. Není na tom nic špatného, jen je třeba na sobě stále pracovat a tyto chyby eliminovat. Doporučuji si tyto zdrojové kódy někam uložit a podívat se na ně po nějaké době, jistě zaznamenáš velký pokrok.

Tedy k věci. Nejprve přikládám pozměněný kód. Opravím chyby, které jsi udělal a následně uvedu zdůvodnění.

Main třída:

package kalkulacka_objekt;
import java.util.Scanner;

/**
 *
 * @author Danie
 */
public class Kalkulacka_objekt {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        Kalkulator kalkulator = new Kalkulator();
        Scanner sc = new Scanner(System.in, "Windows-1250");

        /* O tom, zda se má pokračovat třída Kalkulator vůbec nerozhoduje
         * Již z názvu vypovídá, že je to třída, která bude kalkulovat (počítat),
         * do běhu řídícího cyklu (ten while, co máš níže) nemá co zasahovat
         * navíc je zbytečné využívat String. Tato proměnná nabývá pouze 2 hodnot,
         * což napovídá datový typ boolean (ano -> true, ne -> false)
         * Výsledek není třeba inicializovat ani neklarovat
         */
        boolean pokracovat = true;

        System.out.println("Vítejte v kalkulačce");

        /* Tady se musí změnit podmínka kvůli tomu, že už se stav pokračování
         * uchovává úplně jinak
         * Můžeš si představit jako: while(pokracovat == true) {
         */
        while(pokracovat){
            System.out.println("Zadejte první číslo");
            float a = Float.parseFloat(sc.nextLine());

            System.out.println("Zadejte druhé číslo:");
            float b = Float.parseFloat(sc.nextLine());

            System.out.println("Zvolte si operaci:");
            System.out.println("1 - sčítání");
            System.out.println("2 - odčítání");
            System.out.println("3 - násobení");
            System.out.println("4 - dělení");
            // Je lepší mít ty názvy proměnných přesnější
            int operace = Integer.parseInt(sc.nextLine());

            /* Výsledek nepředáváme, je to k ničemu,
             * ten teprve metoda vypocitej() spočítá
             */
            System.out.println(kalkulator.vypocitej(operace, a, b));

            System.out.println("Přejete si pokračovat? A/n");
            /* Opět kvůli změně výše
             * Dalo by se zkrátit na: pokracovat = (Character.parseChar(sc.nextLine()) === 'A');
             */
            if(Character.parseChar(sc.nextLine()) == 'A')
            {
                pokracovat = true;
            }
            else
            {
                pokracovat = false;
            }
        }

        System.out.println("Děkuji za využití kalkulačky");
    }
}

Třída Kalkulator:

package kalkulacka_objekt;

/**
 *
 * @author Danie
 */
public class Kalkulator {
    /* Tady to chce lepší název metody - měl by to být nějaký rozkaz
     * Název parametru volba opět není nejlepší
     * Není důvod k předávání výsledku - ten se teprve vypočítá
     */
    public String vypocitej(int operace, float a, float b){
        /* Tohle je lepší mít hned na začátku, pokud se uvede chybná volba,
         * mělo by se ihned skončit (nemá smysl pokračovat dál)
         * Skončí se tak, že se zavolá return
         */
        if ((volba < 0) || (volba > 5))
        {
          /* Tady je String.format() zbytečné, to se používá při vkládání proměnné
           * do řetězce
           */
          return "Neplatná volba";
        }

        float vysledek;

        /* Tohle bych řešil spíše přes switch - potom bys nemusel mít
         * ani podmínku nad deklarací proměnné vysledek, ale využil bys
         * výchozí volbu (default)
         * Velkou výhodou je, že nemusíš upravovat okolní kód, když chceš
         * přidat novou operaci nebo nějakou odebrat
         */
        if (operace == 1)
        {
           vysledek = a + b;
        }
        else if (operace == 2)
        {
           vysledek = a - b;
        }
        else if (operace == 3)
        {
           vysledek = a * b;
        }
        else if (operace == 4)
        {
           // TODO: Ošetřit dělení nulou
           vysledek = a / b;
        }

        /* Nyní již můžeš vklidu vrátit výsledek
         * Také zde vidíš použití metody String.format()
         */
        return String.format("Výsledek: %f", vysledek);
    }
}

Většinu věcí jsem nakonec sepsal přímo do kódu. Jen ještě doplním, že je dobré si dělat mezery v kódu pro větší přehlednost. Obvykle po nějakém "bloku" kódu. To není povinné, ale potom se v tom lépe orientuješ. Sice už tam není třídní vlastnost pokracovat, ale stejně k ní něco zmíním. V Javě je třeba psát většinu vlastností jako privátní nebo protected. Tímto porušuješ zapouzdření. V ideálním případě by k vlastnostem přímo (Trida.vlasnost) měla mít přístup jen daná třída. Ostatní by měly využívat pomocné metody - gettery a settery (v dalších článcích je to dobře rozepsané). Také je občas dobré se zamyslet nad pořadím příkazů. Často tím, že nejprve ověříš vstupní parametry metody, ušetříš mnoho času počítači i sobě. Ty nebudeš muset ošetřovat stavy, které by mohly dále vzniknout a počítač úlohu dříve dokončí. Také dávej pozor na pojmenování proměnných, parametrů, metod apod. Je třeba, aby to bylo jasné, výstižné a co nejjednodušší. Zase to pomáhá orientaci v kódu a obecné přehlednosti.

No, to by bylo asi vše. V klidu si to projdi, pročti si mé poznámky a zkus si uvědomit dané chyby. Pokud se stane, že něco nepochopíš, ještě mi odepiš, rád cokoliv doplním.

Odpovědět  +2 24. července 18:27
Nejdůležitější je motivace, ovšem musí být doprovázena činy.
Avatar
Petr Hošek
Člen
Avatar
Petr Hošek:25. července 1:27

muzete mi pomoci? pokazde mi to vraci vysledek 0.

package com.company;

import java.util.Scanner;

public class Kalkulator {
    private float a;
    private float b;
    private int volba;


    public void privitani() {
        System.out.println("Vitejte v kalkulacce!!!");
    }

    public void podekovani() {
        System.out.println("Dekujeme za pouziti kalkulacky");
    }

    public void zobrazeni() {
        System.out.println("1-scitani");
        System.out.println("2-odcitani");
        System.out.println("3-deleni");
        System.out.println("4-nasobeni");
    }

    public float vypocet() {

        float vysledek =0;

        switch (volba) {
            case 1: vysledek=a+b;
            break;
            case 2: vysledek=a-b;
            break;
            case 3: vysledek=a/b;
            break;
            case 4:vysledek=(a*b);
            break;
        }
        return vysledek;

    }
}
package com.company;

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Kalkulator kalkulator=new Kalkulator();
        Scanner sc=new Scanner(System.in,"Windows-1250");
        String pokracovat="ano";
while(pokracovat.equals("ano")){
    kalkulator.privitani();
    System.out.println("Zadejte prvni cislo");
    float a=Float.parseFloat(sc.nextLine());
    System.out.println("Zadejte druhe cislo");
    float b=Float.parseFloat(sc.nextLine());
    kalkulator.zobrazeni();
    System.out.println("Vyberte operaci");
    int volba=Integer.parseInt(sc.nextLine());
    if ((volba>0)&&(volba<5)) {
        System.out.printf("Vysledek je %f ", kalkulator.vypocet());
    }
    else{
        System.out.printf("spatne zadani");
    }
    System.out.println();
    kalkulator.podekovani();
    System.out.printf("Prejete si pokracovat? ano/ne");
    pokracovat = sc.nextLine();
}
}

}
 
Odpovědět 25. července 1:27
Avatar
Danny Holys
Člen
Avatar
Odpovídá na Michal Šmahel
Danny Holys:25. července 2:05

Wow, skvělý!

Děkuji ti moc za to, že jsi si na mě udělal čas. :)

Takhle teď v noci jsem si to narychlo projel a všemu jsem zatím porozuměl. Odpoledne se na to podívám důkladněji a kdyžtak ještě napíšu .)

 
Odpovědět 25. července 2:05
Avatar
Odpovídá na Petr Hošek
Michal Šmahel:25. července 12:28

Ahoj, v metodě Kalkulator.vy­pocet() ti chybí parametr volba. Takhle v proměnné volba (ve zmiňované metodě) není žádná hodnota. Tím pádem se switch vlastně vynechá, protože neobsahuje tu neexistující hodnotu. No a vrátí se výchozí hodnota výsledku - 0.

Odpovědět  +1 25. července 12:28
Nejdůležitější je motivace, ovšem musí být doprovázena činy.
Děláme co je v našich silách, aby byly zdejší diskuze co nejkvalitnější. Proto do nich také mohou přispívat pouze registrovaní členové. Pro zapojení do diskuze se přihlas. Pokud ještě nemáš účet, zaregistruj se, je to zdarma.

Zobrazeno 10 zpráv z 105. Zobrazit vše