Programování v jazyce Java

Prakticky zaměřený bakalářský předmět

Cílem je naučit základním principům objektového programování a algoritmizace

Souvisí s

Předpokládají se základní znalosti strukturované algoritmizace a programování (v rozsahu Úvodu do programování), tj. např.:

Hodnocení má tři složky:

^[1][2]

K ukončení zkouškou potřebujete:

K ukončení zápočtem potřebujete:

Cvičení se konají pod vedením příslušných kvalifikovaných cvičících v počítačových učebnách. Náplň:

Tomáš Pitner

Kód je při běhu dobře zabezpečen:

Konkrétní možnosti:

Javovou platformu tvoří:

(Stav k září 2003:)

Pod Windows jsou to .exe soubory umístěné v podadresáři bin

Zdrojový kód v souboru tomp\ucebnice\Pozdrav.java

package tomp.ucebnice;
public class Pozdrav {
    // Program spouštíme aktivací funkce "main"
    public static void main(String[] args) {
        System.out.println("Ahoj!");
    }
}

Třída Pozdrav je umístěna do balíku tomp.ucebnice ->

její zdrojový soubor musí být uložen v podadresáři tomp\ucebnice.

Překlad

Spuštění

Vytvoření a editace zdrojového kódu v editoru PSPad 4.2.2 (dostupný zdarma, instalovaný na všech Win strojích v učebnách na FI)

Překlad překladačem javac (úspěšný, bez hlášení překladače)

Spuštění voláním java

Spuštění javového programu

= spuštění metody main jedné ze tříd tvořících program

Tato funkce může mít parametry:

Metoda main nevrací žádnou hodnotu - návratový typ je vždy(!) void

Její hlavička musí vypadat vždy přesně tak, jako ve výše uvedeném příkladu, jinak nebude spuštěna!

Cesty ke spustitelným programům (PATH) musejí obsahovat i adresář JAVA_HOME\bin

Systémové proměnné by měly obsahovat:

První cvičení vám pomůže seznámit se s procesem životního cyklus javového programu: zápis a správné umístění zdrojového textu, překlad, spuštění. Proto si jako první krok budete muset vybrat platformu, pod níž budete vaše programy vyvíjet, překládat, spouštět.

Výběr platformy je na vás, ale při odevzdávání hotových úloh se musíte řídit pokyny cvičících, kteří mohou předepsat, v jaké formě zdrojové texty úloh chtějí.

Třída (také poněkud nepřesně zvaná objektový typ) představuje skupinu objektů, které nesou stejné vlastnosti

"stejné" je myšleno kvalitativně, nikoli kvantitativně, tj.

Objekt je jeden konkrétní jedinec (reprezentant, entita) příslušné třídy

pro konkrétní objekt nabývají vlastnosti deklarované třídou konkrétních hodnot

Příklad:

Vlastnostmi objektů jsou:

Vlastnosti objektů - proměnné i metody - je třeba deklarovat.

viz Sun Java Tutorial / Trail: Learning the Java Language: Lesson: Classes and Inheritance

Proměnné

Metody

Mějme deklarovánu třídu Clovek

Metoda main v následujícím programu:

Tedy: vypíší se informace o obou vytvořených objektech - lidech.

Nyní podrobněji k proměnným objektů.

Ve výše uvedeném programu znamenalo na řádku:

        Clovek ales = new Clovek("Ales Necas", 1966);

Clovek ales: pouze deklarace (tj. určení typu) proměnné ales - bude typu Clovek.

ales = new Clovek ("Ales Necas", 1966): vytvoření objektu Clovek se jménem Ales Necas.

Lze napsat zvlášť do dvou řádků nebo (tak jak jsme to udělali) na řádek jeden.

Každý příkaz i deklaraci ukončujeme středníkem.

Položky jmeno a rokNarozeni v předchozím příkladu jsou proměnné objektu Clovek.

Jsou deklarovány v těle deklarace třídy Clovek.

Deklarace proměnné objektu má tvar:

modifikátoryTypjméno;

např.:

protected int rokNarozeni;

Výše uvedená proměnná rokNarozeni měla datový typ int (32bitové celé číslo). Tedy:

Kromě celých čísel int nabízí Java celou řadu dalších primitivních datových typů. Primitivní typy jsou dané napevno, programátor je jen používá, nedefinuje. Podrobněji viz Datové typy v Javě

Tam, kde nestačí diskrétní hodnoty (tj. primitivní typy), musíme použít typy složené, objektové.

Na jméno (identifikátor) proměnné sice Java neklade žádná speciální omezení (tedy mimo omezení platná pro jakýkoli identifikátor), ale přesto bývá velmi dobrým zvykem dodržovat při pojmenovávání následující pravidla (blíže viz podrobný rozbor na FIXME):

např.:

protected int rokNarozeni;

je identifikátor se správně (vhodně) utvořeným jménem, zatímco:

protected int RokNarozeni;

není vhodný identifikátor proměnné (začíná velkým písmenem)

Dodržování těchto jmenných konvencí je základem psaní srozumitelných programů a bude vyžadováno, sledováno a hodnoceno v odevzdávaných úlohách i písemkách.

Proměnné objektu odkazujeme pomocí "tečkové notace":

public class TestLidi2 { 
    public static void main(String[] args) { 
        ... 
        Clovek ales = new Clovek("Ales Necas", 1966); // vytvoření objektu
        ... 
        System.out.println(ales.jmeno); // přístup k (čtení) jeho proměnné
        ...
        ales.jmeno = "Aleš Novák"; // modifikace (zápis do) jeho proměnné
    }
}       

Přístup k proměnným (i metodám) může být řízen uvedením tzv. modifikátorů před deklaraci prvku, viz výše:

// protected = přístup pouze z třídy ve stejném balíku nebo z podtřídy:

    protected String jmeno;
       

Modifikátorů je více typů, nejběžnéjší jsou právě zmíněné modifikátory přístupu (přístupových práv)

Objektů (tzv. instancí) stejného typu (tj. stejné třídy) si můžeme postupně vytvořit více:

public class TestLidi3 { 
    public static void main(String[] args) { 
        ... 
        Clovek ales = new Clovek("Ales Necas", 1966);   // vytvoření prvniho objektu
        Clovek petr = new Clovek("Petr Svoboda", 1968); // vytvoření druheho objektu
        ... 
        System.out.println(ales.jmeno); // přístup k (čtení) proměnné prvniho
        System.out.println(petr.jmeno); // přístup k (čtení) proměnné prvniho
    }
}       

Existují tady dva objekty, každý má své (obecně různé) hodnoty proměnných - např. jsou různá jména obou lidí.

Ve výše uvedených příkladech jsme objekty vytvářeli voláními new Clovek(...) bezděčně jsme tak použili

Nad existujícími (vytvořenými) objekty můžeme volat jejich metody. Metoda je:

Každá metoda se musí ve své třídě deklarovat.

V Javě neexistují metody deklarované mimo třídy (tj. Java nezná žádné "globální" metody).

Výše uvedená třída Clovek měla metodu na výpis informací o daném objektu/člověku:

public class Clovek {
    protected String jmeno;
    protected int rokNarozeni;
    public Clovek(String j, int rN) {
        jmeno = j;
        rokNarozeni = rN;
    }

    // Metoda vypisInfo() na výpis informací o člověku:
    public void vypisInfo() {
        System.out.println("Clovek:");
        System.out.println("Jmeno="+jmeno);
        System.out.println("Rok narozeni="+rokNarozeni);
    }
}

Vracíme se k prvnímu příkladu: vytvoříme dva lidi a zavoláme postupně jejich metodu vypisInfo.

public class TestLidi {
    public static void main(String[] args) {

        Clovek ales = new Clovek("Ales Necas", 1966);
        Clovek beata = new Clovek("Beata Novakova", 1970);

        ales.vypisInfo();  // volání metody objektu ales
        beata.vypisInfo(); // volání metody objektu beata
    }
}

Vytvoří se dva objekty Clovek a vypíší se informace o nich.

V deklaraci metody uvádíme v její hlavičce tzv. formální parametry.

Syntaxe:

modifikatorytypVraceneHodnotynazevMetody
(
seznamFormalnichParametru
) {

    
tělo (výkonný kód) metody


}

seznamFormalnichParametru je tvaru: typParametrunazevFormalnihoParametru, ...

Podobně jako v jiných jazycích parametr představuje v rámci metody lokální proměnnou.

Při volání metody jsou f. p. nahrazeny skutečnými parametry.

Hodnoty primitivních typů - čísla, logické hodnoty, znaky

Hodnoty objektových typů - všechny ostatní (tj. vč. všech uživatelem definovaných typů)

V Javě tedy nemáme jako programátoři moc na výběr, jak parametry předávat

Rozšiřme definici třídy Clovek o metodu zakric s parametry:

    ...
    public void zakric(int kolikrat) {
        System.out.println("Kricim " + kolikrat + "krat UAAAA!");
    }
    ...  

Při zavolání:

    ...
    zakric(10);
    ...  

tato metoda vypíše

Kricim 10krat UAAAA!

Následující třída Ucet modeluje jednoduchý bankovní účet s možnostmi:

public class Ucet {

    // stav (zustatek) penez uctu
    protected double zustatek;

    public void pridej(double castka) {
        zustatek += castka;
    }
    public void vypisZustatek() {
        System.out.println(zustatek);
    }
    public void prevedNa(Ucet kam, double castka) {
        zustatek -= castka; 
        kam.pridej(castka);
    }
}

Metoda prevedNa pracovat nejen se svým "mateřským" objektem, ale i s objektem kam předaným do metody... opět přes tečkovou notaci.

Příklad použití třídy Ucet:

    ...
    public static void main(String[] args) {
        Ucet petruvUcet = new Ucet();
        Ucet ivanuvUcet = new Ucet();
        petruvUcet.pridej(100);
        ivanuvUcet.pridej(220);
        petruvUcet.prevedNa(ivanuvUcet, 50);
        petruvUcet.vypisZustatek();
        ivanuvUcet.vypisZustatek();
    }

Kód metody skončí, tj. předá řízení zpět volající metodě (nebo systému - v případě startovní metody main), jakmile

Metoda může při návratu vrátit hodnotu - tj. chovat se jako funkce (ve pascalském smyslu):

Pozn.: I když metoda něco vrátí, my to nemusíme použít, ale je to trochu divné...

Co a k čemu jsou konstruktory?

Syntaxe (viz výše):

public class Clovek {
    protected String jmeno;
    protected int rokNarozeni;

    // konstruktor se dvěma parametry
    // - inicializuje hodnoty proměnných ve vytvořeném objektu
    public Clovek(String j, int rN) {
        jmeno = j;
        rokNarozeni = rn;
    }
    ...
}

Příklad využití tohoto konstruktoru:

    ...
    Clovek pepa = new Clovek("Pepa z Hongkongu", 1899);
    ...

Toto volání vytvoří objekt pepa a naplní ho jménem a rokem narození.

Jak je psát a co s nimi lze dělat?

Jedna třída může mít:

Ve třídě Ucet přetížíme metodu prevedNa.

    public void prevedNa(Ucet u) {
        u.pridej(zustatek);
        zustatek = 0;
    }

Ve třídě Ucet koexistují dvě různé metody se stejným názvem, ale jinými parametry.

Pozn: I když jsou to teoreticky dvě úplně různé metody, pak když už se jmenují stejně, měly by dělat něco podobného.

Objekty:

Deklarace proměnné objektového typu ještě žádný objekt nevytváří.

To se děje až příkazem - operátorem - new.

V následující ukázce vytvoříme dva účty.

    ...
    public static void main(String[] args) {
        Ucet petruvUcet = new Ucet();
        Ucet ivanuvUcet = new Ucet();
        Ucet u;
        petruvUcet.pridej(100);
        ivanuvUcet.pridej(220);
        u = petruvUcet;
        u.prevedNa(ivanuvUcet, 50); // odečte se z Petrova účtu
        petruvUcet.vypisZustatek(); // vypíše 50
        ivanuvUcet.vypisZustatek();
    }

Metoda může vracet odkaz na objekt, nad nímž je volána pomocí

return this;

Příklad - upravený Ucet s metodou prevedNa vracející odkaz na sebe

public class Ucet {
    float zustatek;
    public void pridej(float castka) {
        zustatek += castka;
    }
    public void vypisZustatek() {
        System.out.println(zustatek);
    }
    public Ucet prevedNa(Ucet u, float castka) {
        zustatek -= castka; // nebo také vhodné je: pridej(-castka);
        u.pridej(castka);
        return this;
    }
}

Vracení odkazu na sebe (tj. na objekt, na němž se metoda volala) lze s výhodou využít k "řetězení" volání:

    ...
    public static void main(String[] args) {
        Ucet petruvUcet = new Ucet();
        Ucet ivanuvUcet = new Ucet();
        Ucet igoruvUcet = new Ucet();
        petruvUcet.pridej(100);
        ivanuvUcet.pridej(100);
        igoruvUcet.pridej(100);

        // budeme řetězit volání:
        petruvUcet.prevedNa(ivanuvUcet, 50).prevedNa(igoruvUcet, 20);

        petruvUcet.vypisZustatek(); // vypíše 30
        ivanuvUcet.vypisZustatek(); // vypíše 150
        igoruvUcet.vypisZustatek(); // vypíše 120
    }

Dosud jsme zmiňovali proměnné a metody (tj. souhrnně prvky - members) objektu.

Lze deklarovat také metody a proměnné patřící celé třídě, tj. skupině všech objektů daného typu. Ttakové metody a proměnné nazýváme statické a označujeme v deklaraci modifikátorem static

Představme si, že si budeme pamatovat, kolik lidí se nám během chodu programu vytvořilo a vypisovat tento počet.

Budeme tedy potřebovat do třídy Clovek doplnit:

public class Clovek {
    protected String jmeno;
    protected int rokNarozeni;
    protected static int pocetLidi = 0;
    public Clovek(String j, int rN) {
        jmeno = j;
        rokNarozeni = rn;
        pocetLidi++;
    }
    ...
    public static int kolikMamLidi() {
        return pocetLidi;
    }
    ...
}

Pozn: Všimněte si v obou případech modifikátoru/klíčového slova static.

Druhé cvičení vás pomůže nacvičit práci s více jednoduchými objekty několika tříd.

Vše, co vytvoříte i překopírujete, budete umisťovat do balíku cz.muni.fi.{vaslogin}.banka a odevzdáte podle pokynů cvičícího. Cvičící si může zadání upravit - toto je jen vzor.

Úkolem bude:

Generický (univerzální, obecný...) model postupu:

(podle JS, SW inženýrství):

V tomto předmětu nás z toho bude zajímat jen něco a jen částečně:

Tyto generické modely jsou dále rozpracovávány do podoby konkrétních metodik.

Metodika (tvorby SW) je ucelený soubor inženýrských postupů, jak řízeným způsobem, s odhadnutelnou spotřebou zdrojů dospět k použitelnému SW produktu.

Některé skupiny metodik:

Nevracím se nikdy o více jak jednu úroveň zpět:

Nyní zpět k Javě a jednoduchým programům...

Co bude odlišné oproti dosavadním programátorským zkušenostem?

Struktura a rozsah programu:

Pascal: program měl jeden nebo více zdrojových souborů (soubor = modul) tvořenými jednotlivými procedurami/fcemi, definicemi a deklaracemi (typů, proměnných...)

Java (a některé další OO jazyky): program je obvykle tvořen více soubory (soubor = popis jedné třídy) tvořenými deklaracemi metod a proměnných (případně dalších prvků) těchto tříd.

v Pascalu nebyla (nutná)

v Javě je nezbytná - zdrojové soubory organizujeme podle toho, ve kterých balících jsou třídy zařazeny

(přeložené soubory se implicitně ukládájí vedle zdrojových)

Zkusme naznačit, jak bychom realizovali jednoduchý systém, který bude

Zjistíme, jaké typy objektů se ve zkoumaném výseku reality vyskytují a které potřebujeme zachytit

člověk, pes, veterinář

Zjistíme a zachytíme vztahy mezi objekty našeho zájmu

člověk-chovatel vlastní psa

Zjistíme, které činnosti objekty (aktéři, aktoři) provádějí

veterinář psa očkuje, pes štěká, kousne člověka...

neformálními prostředky - tužkou na papíře vlastními slovy v přirozeném jazyce

formálně pomocí nějakého vyjadřovacího aparátu - např. grafického jazyka

pomocí CASE nástroje přímo na počítači

Zatím se přidržíme neformálního způsobu...

Určení základních tříd, tj.

skupin (kategorií) objektů, které mají podobné vlastnosti/schopnosti:

Soubor Zivocich.java bude obsahovat (pozor na velká/malá písmena - v obsahu i názvu souboru):

public class Zivocich { ... popis vlastností (proměnných, metod...) živočicha ...

}

public značí, že třída je "veřejně" použitelná, tj. i mimo balík

Třídy zorganizujeme do balíků.

V balíku jsou vždy umístěny související třídy.

Co znamená související?

třídy, jejichž objekty spolupracují - člověk, úřad

třídy na podobné úrovni abstrakce - chovatel, domácí zvíře

třídy ze stejné části reality - chovatel psů, pes

Balíky obvykle organizujeme do hierarchií, např.:

Neplatí však, že by

Hierarchie balíků má tedy význam spíše pro srozumitelnost a logické členění.

Deklarujeme ji syntaxí: package názevbalíku;

V realitě jsme často svědci toho, že třídy jsou podtřídami jiných:

Podtřída je tedy "zjemněním" nadtřídy:

V Javě je každá uživatelem definovaná třída potomkem nějaké jiné - neuvedeme-li předka explicitně, je předkem vestavěná třída Object

Terminologie:

Dědění může mít i více "generací", např.

Zivocich <- Clovek <- Chovatel (živočich je rodičovskou třídou člověka, ten je rodičovskou třídou chovatele)

Přeneseně tedy předkem (nikoli bezprostředním) chovatele je živočich.

Klíčovým slovem extends:

public class Clovek extends Zivocich {

... popis vlastností (proměnných, metod...) člověka navíc oproti živočichovi ...

}

Deklarace import nesouvisí s děděním, ale s organizací tříd programu do balíků:

Import není nutné deklarovat mezi třídami téhož balíku!

Pak lze používat všechny třídy z uvedeného balíku

Doporučuje se "import s hvězdičkou" nepoužívat:

"Hvězdičkou" nezpřístupníme třídy z podbalíků, např.

Jak víme, třídy popisují skupiny objektů podobných vlastností

Třídy mohou mít tyto skupiny vlastností:

Vlastnosti jsou ve třídě "schované", tzv. zapouzdřené (encapsulated)

Třída připomíná pascalský záznam (record), ten však zapouzdřuje jen proměnné, nikoli metody.

Dědičnost (alespoň v javovém smyslu) znamená, že dceřinná třída (podtřída, potomek)

Cíl: vylepšit třídu Ucet

Postup:

Vzorový zdroják sám o sobě nepůjde přeložit, protože nemáme třídu, na níž závisí. Celý kód vystavím až po kontrole příslušných úloh.

Přístup ke třídám i jejim prvkům lze (podobně jako např. v C++) regulovat:

Přístup je v Javě regulován jednotlivě po prvcích

ne jako v C++ po blocích

Omezení přístupu je určeno uvedením jednoho z tzv. modifikátoru přístupu (access modifier) nebo naopak neuvedením žádného.

Pro třídy:

Pro vlastnosti tříd = proměnné/metody:

public => přístupné odevšad

public class Ucet { ... } 

třída Ucet je veřejná = lze např.

protected => přístupné jen z podtříd a ze tříd stejného balíku

public class Ucet { 
        // chráněná proměnná
        protected float povolenyKontokorent; 
} 

používá se jak pro metody (velmi často), tak pro proměnné (méně často)

lokální v balíku = přátelský => přístupné jen ze tříd stejného balíku, už ale ne z podtříd, jsou-li v jiném balíku

public class Ucet {
        Date created; // přátelská proměnná 
} 

private => přístupné jen v rámci třídy, ani v podtřídách - používá se častěji pro proměnné než metody

označením private prvek zneviditelníme i případným podtřídám!

public class Ucet { 
    private String majitel;
    ... 
} 

Nastavení přístupových práv k třídě pomocí modifikátorů se děje na úrovni tříd, tj. vztahuje se pak na všechny objekty příslušné třídy i na její statické vlastnosti (proměnné, metody) atd.

Nastavení musí vycházet z povahy dotyčné proměnné či metody.

Nevíme-li si rady, jaká práva přidělit, řídíme se následujícím:

Cílem třetí úlohy je zvládnutí jednoduchého použití dědičnosti v objektovém programu. Hotovým základem je balík tomp.ucebnice.auta, v něm třídy Auto a Demo. Třídy tohoto balíku si stáhněte k sobě a pracujte s nimi lokálně (i když na UNIXech je teoreticky lze namapovat přímo z cesty /home/tomp/public_html/java/ucebnice/javasrc/ a dále.... Auto představuje třídu vozidel - aut, od této třídy zatím nebudeme vytvářet speciálnější typy aut - osobní, nákladní. Demo je třída, která musí fungovat, jakmile jí poskytneme/dopíšeme níže uvedené třídy.

Do balíku tomp.ucebnice.auta.mycky napište třídy Mycka, RucniMycka a MyckaSUdrzbou tak, aby potomkem - podtřídou třídy Mycka byla RucniMycka a jejím potomkem MyckaSUdrzbou.

Třída Mycka musí umět auto umýt (metoda s hlavičkou public double umyj(Auto a) - vrací cenu za umytí jako hodnotu typu double - cenu si zvolte sami dle uvážení...), obdobně navoskovat (metoda navoskovat) a musí nabízet "kompletní program" (metoda kompletniProgram) se slevou 20 % součtu cen jednotlivých služeb v rámci programu.

Třída RucniMycka musí umět totéž jako Mycka a navíc musí umět čištění interiéru (metoda s hlavičkou public double vycistiInterier(Auto a)). Její "kompletní program" (metoda kompletniProgram) bude dostupný za cenu podobně spočtenou jako v předchozí třídě a bude obsahovat navíc čištění interiéru.

Třída MyckaSUdrzbou musí umět totéž jako RucniMycka a navíc musí umět údržbu spodku vozidla (metoda s hlavičkou public double provedUdrzbuSpodku(Auto a)). Její "kompletní program" (metoda kompletniProgram) bude dostupný za cenu podobně spočtenou jako v předchozí třídě a bude obsahovat navíc údržbu spodku.

Výsledkem - Vašim řešením - jsou tedy dopsané třídy umístěné v balíku tomp.ucebnice.auta.mycky.

Pozn: ve třídách balíku tomp.ucebnice.auta.mycky budete v metodách používat třídu Auto - parametr typu Auto. Abyste jej v tomto místě zpřístupnili (je totiž v jiném balíku), musíte napřed deklarací třídy (po package, před class...) uvést import tomp.ucebnice.auta.Auto; - blíže viz slidy.

Přiřazovací příkaz =

Řízení toku programu (větvení, cykly)

Volání metody

Návrat z metody - příkaz return

Příkaz je ukončen středníkem ;

v Pascalu středník příkazy odděluje, v Javě (C/C++) ukončuje

Operátor přiřazení = (assignment)

na levé straně musí být proměnná

na pravé straně výraz přiřaditelný (assignable) do této proměnné

Rozlišujeme přiřazení primitivních hodnot a odkazů na objekty

Na pravé straně výraz vracející hodnotu primitivního typu

číslo, logická hodnotu, znak (ale ne např. řetězec)

Na levé straně proměnná téhož typu jako přiřazovaná hodnota nebo typu širšího

např. int lze přiřadit do long

Při zužujícím přiřazení se také provede konverze, ale může dojít ke ztrátě informace

např. int -> short

Přiřazením primitivní hodnoty se hodnota zduplikuje ("opíše") do proměnné na levé straně.

Konstrukci = lze použít i pro přiřazení do objektové proměnné:

Zivocich z1 = new Zivocich();

Co to udělalo?

Nyní můžeme odkaz na tentýž vytvořený objekt znovu přiřadit - do z2:

Zivocich z2 = z1;

Proměnné z1 a z2 ukazují nyní na stejný objekt typu živočich!!!

Proměnné objektového typu obsahují odkazy (reference) na objekty, ne objekty samotné!!!

Metoda objektu je vlastně procedura/funkce, která realizuje svou činnost primárně s proměnnými objektu.

Volání metody určitého objektu realizujeme:

identifikaceobjektu.názevmetody(skutečnéparametry)

Buďto automaticky posledním příkazem v těle metody

nebo explicitně příkazem return návratováhodnota

způsobí ukončení provádění těla metody a návrat, přičemž může být specifikována návratová hodnota

typ skutečné návratové hodnoty musí korespondovat s deklarovaným typem návratové hodnoty

Příkaz (neúplného) větvení if

if (logický výraz) příkaz

platí-li logický výraz (má hodnoty true), provede se příkaz

Příkaz úplného větvení if - else

if (logický výraz) 
    příkaz1 
else 
    příkaz2        

platí-li logický výraz (má hodnoty true), provede se příkaz1

neplatí-li, provede se příkaz2

Větev else se nemusí uvádět

Tělo cyklu se provádí tak dlouho, dokud platí podmínka

obdoba while v Pascalu

v těle cyklu je jeden jednoduchý příkaz ...

while (podmínka) 
    příkaz;      

... nebo příkaz složený

while (podmínka) { 
    příkaz1; 
    příkaz2; 
    příkaz3;
    ... 
} 

Tělo cyklu se nemusí provést ani jednou - pokud už hned na začátku podmínka neplatí

Větvení, cykly: doporučuji vždy psát se složeným příkazem v těle (tj. se složenými závorkami)!!!

jinak hrozí, že se v těle větvení/cyklu z neopatrnosti při editaci objeví něco jiného, než chceme, např.:

while (i < a.length) 
    System.out.println(a[i]); i++; 

i

Pišme proto vždy takto:

while (i < a.length) {
    System.out.println(a[i]); i++; 
} 

Dokud nejsou přečteny všechny vstupní argumenty:

int i = 0;
while (i < args.length) {
    "přečti argument args[i]"
    i++;
}

Dalším příkladem je použití while pro realizaci celočíselného dělení se zbytkem:

Celočíselné dělení se zbytkem

Tělo se provádí dokud platí podmínka (vždy aspoň jednou)

obdoba repeat v Pascalu (podmínka je ovšem interpretována opačně)

Relativně málo používaný - je méně přehledný než while

Syntaxe:

do {
    příkaz1;
    příkaz2;
    příkaz3;
    ...
} while (podmínka);

Dokud není z klávesnice načtena požadovaná hodnota:

String vstup = ""; 
float cislo; 
boolean nacteno; // vytvoř reader ze standardního vstupu 
BufferedReader in = new BufferReader(new InputStream(System.in)); // dokud není zadáno číslo, čti 
do { 
    vstup = in.readLine(); 
    try { 
        cislo = Float.parseFloat(vstup); 
        nacteno = true; 
    } catch (NumberFormatException nfe) { 
        nacteno = false;
    }
} while (!nacteno);
System.out.println("Nacteno cislo "+cislo); 
        

Načítej, dokud není zadáno číslo

obecnější než for v Pascalu, podobně jako v C/C++

De-facto jde o rozšíření while, lze jím snadno nahradit

Syntaxe:

for (počáteční operace; vstupní podmínka; příkaz po každém průchodu) 
    příkaz; 

anebo (obvyklejší, bezpečnější)

for (počáteční operace; vstupní podmínka; příkaz po každém průchodu) { 
    příkaz1; 
    příkaz2;
    příkaz3; 
    ... 
} 

Provedení určité sekvence určitý počet krát

for (int i = 0; i < 10; i++) {
    System.out.println(i); 
} 

Vypíše na obrazovku deset řádků s čísly postupně 0 až 9 Pět pozdravů nebo Výpis prvků pole objektů "for" cyklem

Používejte asymetrické intervaly (ostrá a neostrá nerovnost):

podmínka daná počátečním přiřazením i = 0 a inkrementací i++ je neostrou nerovností, zatímco

opakovací podmínka i < 10 je ostrou nerovností -> i už nesmí hodnoty 10 dosáhnout!

Vytvarujte se složitých příkazů v hlavičce (kulatých závorkách) for cyklu -

je lepší to napsat podle situace před cyklus nebo až do jeho těla

Někteří autoři nedoporučují psát deklaraci řídicí proměnné přímo do závorek cyklu

for (int i = 0; ...

ale rozepsat takto:

int i; 
for (i = 0; ... 

potom je proměnná i přístupná ("viditelná") i mimo cyklus - za cyklem, což se však ne vždy hodí.

Obdoba pascalského select - case - else

Větvení do více možností na základě ordinální hodnoty

Syntaxe:

switch(výraz) { 
    case hodnota1: prikaz1a;
                   prikaz1b; 
                   prikaz1c; 
                   ... 
                   break; 
    case hodnota2: prikaz2a; 
                   prikaz2b; 
                   ...
                   break; 
    default:       prikazDa; 
                   prikazDb; 
                   ...
} 

Je-li výraz roven některé z hodnot, provede se sekvence uvedená za příslušným case. Sekvenci obvykle ukončujeme příkazem break, který předá řízení ("skočí") na první příkaz za ukončovací závorkou příkazu switch.Vícecestné větvení

Větvení if - else můžeme samozřejmě vnořovat do sebe:

if (podmínka_vnější) {
    if (podmínka
vnitřní
1) {
        ...
    } else {
        ...
    }
} else {
    if (podmínka
vnitřní
2) {
        ...
    } else {
        ...
    }
}

Je možné "šetřit" a neuvádět složené závorky, v takovém případě se else vztahuje vždy k nejbližšímu neuzavřenému if, např. znovu předchozí příklad:

if (podmínka_vnější)
    if (podmínka
vnitřní
1)
        ...
    else // vztahuje se k nejbližšímu if
         // s if (podmínka
vnitřní
1)
        ...
else // vztahuje se k prvnímu if,
     // protože je v tuto chvíli
     // nejbližší neuzavřené
    if (podmínka
vnitřní
2)
        ...
    else // vztahuje se k if (podmínka
vnitřní
2)
        ...

Tak jako u cyklů - tento způsob zápisu nelze v žádném případě doporučit!!!

Vnořené větvení

Někdy rozvíjíme pouze druhou (negativní) větev:

if (podmínka1) {
    ...
} else if (podmínka2) {
    ...
} else if (podmínka3) {
    ...
} else {
    ...
}

Neplatí-li podmínka1, testuje se podmínka2, neplatí-li, pak podmínka3...

neplatí-li žádná, provede se příkaz za posledním - samostatným - else.

Opět je dobré všude psát složené závorky!!!

Řetězené if

Realizuje "násilné" ukončení průchodu cyklem nebo větvením switch

Syntaxe použití break v cyklu:

for (int i = 0; i < a.length; i++) { 
    if(a[i] == 0) { 
        break; // skoci se za konec cyklu 
    }
} 
if (a[i] == 0) {
    System.out.println("Nasli jsme 0 na pozici "+i); 
} else {
    System.out.println("0 v poli neni"); 
} 

použití u switch jsme již viděliVícecestné větvení "switch - case - default"

Používá se v těle cyklu.

Způsobí přeskočení zbylé části průchodu tělem cyklu

for (int i = 0; i < a.length; i++) { 
    if (a[i] == 5) 
        continue; 
    System.out.println(i); 
} 

Výše uvedený příklad vypíše čísla 1, 2, 3, 4, 6, 7, 8, 9, nevypíše hodnotu 5. Řízení průchodu cyklem pomocí "break" a "continue"

Umožní ještě jemnější řízení průchodu vnořenými cykly

pomocí návěští můžeme naznačit, který cyklus má být příkazem break přerušen nebo

tělo kterého cyklu má být přeskočeno příkazem continue. Návěští

Raději NEPOUŽÍVAT, ale jsou menším zlem než by bylo goto (kdyby v Javě existovalo...), protože nepředávají řízení dále než za konec struktury (cyklu, větvení).

Toto však již neplatí pro break a continue na návěští!

Poměrně často se používá break při sekvenčním vyhledávání prvku

Jednoduché vlastní implementace vyhledávacích a řadicích algoritmů (Lineární a binární vyhledávání)

Úvod

Tato úloha bude používat pole, které se dosud na přednáškách zmiňovalo jen v souvislosti s argumenty metody main, konkrétně v její hlavičce jsme viděli: main(String[] args).

Ani tato úloha ale nebude vyžadovat více znalostí o práci s polem, než jen to, že:

Část I.Cílem je napsat dvě třídy, jejichž objekty budou umět:

Dále pak napsat dvě třídy rozšiřující dvě výše uvedené tak, aby navíc:

Jak se budou třídy lišit:

Jak postupovat:

Část II.Řazení probubláváním a quicksort

Cílem je napsat dvě třídy objektů, jejichž objekty budou umět:

Jak se budou dvě třídy lišit:

Jak postupovat:

Pozn: Pokud cvičící zadání modifikuje, je to OK. Tohle je vzorové zadání. Za obě části úlohy dohromady získáte opět max. 5 bodů.

Java striktně rozlišuje mezi hodnotami

Základní rozdíl je v práci s proměnnými:

Důsledek -> dvě objektové proměnné mohou nést odkaz na tentýž objekt

Proměnné těchto typů nesou elementární, z hlediska Javy atomické, dále nestrukturované hodnoty.

Deklarace takové proměnné (kdekoli) způsobí:

V Javě existují tyto skupiny primitivních typů:

V Javě jsou celá čísla vždy interpretována jako znaménková

"Základním" celočíselným typem je 32bitový int s rozsahem -2 147 483 648 až 2147483647

větší rozsah (64 bitů) má long, cca +/- 9*10^18

menší rozsah mají

Pro celočíselné typy existují (stejně jako pro floating-point typy) konstanty - minimální a maximální hodnoty příslušného typu. Tyto konstanty mají název vždy Typ.MIN_VALUE, analogicky MAX... Viz např. Minmální a maximální hodnoty

char představuje jeden 16bitový znak v kódování UNICODE

Konstanty typu char zapisujeme

Java vnitřně kóduje znaky a řetězce v UNICODE, pro vstup a výstup je třeba použít některou za serializací (převodu) UNICODE na sekvence bajtů:

Problém může nastat při interpretaci kódování znaků národních abeced přímo ve zdrojovém textu programu.

Ve zdroj. textu správně napsaného javového vícejazyčného programu by žádné národní znaky VŮBEC neměly vyskytovat.

Je vhodné umístit je do speciálních souborů tzv. zdrojů (v Javě objekty třídy java.util.ResourceBundle).

Kódována podle ANSI/IEEE 754-1985

Možné zápisy literálů typu float (klasický i semilogaritmický tvar) - povšimněte si "f" za číslem - je u float nutné!:

float f = -.777f, g = 0.123f, h = -4e6f, 1.2E-15f;

double: tentýž zápis, ovšem bez "f" za konstantou!, s větší povolenou přesností a rozsahem

Kladné a záporné nekonečno:

Konstanta NaN - Not A Number

Viz také Minimální a maximální hodnoty

Přípustné hodnoty jsou false a true.

Na rozdíl od Pascalu na nich není definováno uspořádání.

Význam podobný jako v C/C++.

Není v pravém slova smyslu datovým typem, nemá žádné hodnoty.

Označuje "prázdný" typ pro sdělení, že určitá metoda nevrací žádný výsledek.

Pole v Javě je speciálním objektem

Můžeme mít pole jak primitivních, tak objektových hodnot

Kromě pole v Javě existují i jiné objekty na ukládání více hodnot - tzn. kontejnery, viz dále

Syntaxe deklarace

typhodnoty[]jménopole

na rozdíl od C/C++ nikdy neuvádíme při deklaraci počet prvků pole - ten je podstatný až při vytvoření objektu pole

Syntaxe přístupu k prvkům

jménopole[indexprvku]

Používáme

Syntaxe vytvoření objektu pole: jako u jiného objektu - voláním konstruktoru:

jménopole = new typhodnoty[početprvků];

nebo vzniklé pole rovnou naplníme hodnotami/odkazy

jménopole
 = new
      
typhodnoty
[] 
{prvek1,
      prvek2, ...}
; 

Pole je objekt, je třeba ho před použitím nejen deklarovat, ale i vytvořit:

Clovek[] lidi; lidi = new Clovek[5];
        

Clovek

Nyní můžeme pole naplnit:

lidi[0] = new Clovek("Václav Klaus",
        Clovek.MUZ); lidi[1] = new Clovek("Libuše Benešová",
        Clovek.ZENA); 

lidi[0].vypisInfo(); lidi[1].vypisInfo();
        

Co kdybychom pole pouze deklarovali a nevytvořili:

Clovek[] lidi;
lidi[0] = new Clovek("Václav Klaus", Clovek.MUZ);

Toto by skončilo s běhovou chybou "NullPointerException", pole neexistuje, nelze do něj tudíž vkládat prvky!

Pokud tuto chybu uděláme v rámci metody:

public class Pokus {
    public static void main(String args[]) {
        String[] pole;
        pole[0] = "Neco";
    }
}

překladač nás varuje:

Pokus.java:4: variable pole might not have been initialized
        pole[0] = "Neco";
        ^
1 error

Pokud ovšem pole bude proměnnou objektu/třídy:

public class Pokus {
    static String[] pole;
    public static void main(String args[]) {
        pole[0] = "Neco";
    }
}

Překladač chybu neodhalí a po spuštění se objeví:

Exception in thread "main" java.lang.NullPointerException
        at Pokus.main(Pokus.java:4)

Co kdybychom pole deklarovali, vytvořili, ale nenaplnili příslušnými prvky:

Clovek[] lidi;
lidi = new Clovek[5];
lidi[0].vypisInfo();

Toto by skončilo také s běhovou chybou NullPointerException:

V Javě obecně přiřazení proměnné objektového typu vede pouze k duplikaci odkazu, nikoli celého odkazovaného objektu.

Nejinak je tomu u polí, tj.:

Clovek[] lidi2; 
lidi2 = lidi1; 

V proměnné lidi2 je nyní odkaz na stejné pole jako je v lidi1.

Zatímco, provedeme-li vytvoření nového pole + arraycopy, pak lidi2 obsahuje duplikát/klon/kopii původního pole.

Clovek[] lidi2 = new Clovek[5];
System.arraycopy(lidi, 0, lidi2, 0, lidi.length); 

viz též Dokumentace API třídy "System"

Samozřejmě bychom mohli kopírovat prvky ručně, např. pomocí for cyklu, ale volání System.arraycopy je zaručeně nejrychlejší a přitom stále platformově nezávislou metodou, jak kopírovat pole.

Také arraycopy však do cílového pole zduplikuje jen odkazy na objekty, nevytvoří kopie objektů!

V Javě, na rozdíl od C++ neexistuje vícenásobná dědičnost -

Pokud po třídě chceme, aby disponovala vlastnostmi z několika různých množin (skupin), můžeme ji deklarovat tak, že

Příklad deklarace rozhraní

public interface Informujici {
    void vypisInfo();
}

Příklad

public class Clovek implements Informujici {
    ...
    public void vypisInfo() {
        ...
    }
}

Čteme: Třída Clovek implementuje rozhraní Informujici.

Příklad

    Informujici petr = new Clovek("Petr Novák", 1945);
    petr.vypisInfo(); // "petr" stačí deklarovat jen jako Informujici
                      // jiné metody než předepsané tímto intf. 
                      // nepotřebujeme!

Třída sice smí dědit maximálně z jedné nadtřídy (předka), ale

Příklad - kromě výše uvedeného intf. Informujici mějme ještě:

public interface Kricici { 
    void zakric(); 
}
        

Třída Clovek implementuje dvě rozhraní:

public class Clovek implements Informujici, Kricici { 
    ... 
    public void vypisInfo() { 
        ... 
    } 
    public void zakric() {
        ... 
    }
} 

Podobně jako u tříd, i rozhraní mohou být rozšiřována/specializována. Mohou dědit.

Na rozdíl od třídy, která dědí maximálně z jedné nadtřídy (předka) -

Přesto to nepřináší problémy jako u klasické plné vícenásobné dědičnosti např. v C++, protože rozhraní samo

Příklad - Informujici informuje „jen trochu“, DobreInformujici je schopen ke standardním informacím (vypisInfo) přidat dodatečné informace (vypisDodatecneInfo).

public interface Informujici {
    void vypisInfo();
}

public interface DobreInformujici extends Informujici { 
    void vypisDodatecneInfo(); 
}

Třída, která chce implementovat intf. DobreInformujici, musí implementovat obě metody předepsané tímto rozhraním. Např.:

public class Informator implements DobreInformujici { 
    public void vypisInfo() {
        ... // kód metody
    }
    public void vypisDodatecneInfo() {
        ... // kód metody
    }
}

I když Java disponuje rozhraními, někdy je vhodné určitou specifikaci implementovat pouze částečně:

Abstraktní třída je tak označena v hlavičce, např.:

public abstract class AbstraktniChovatel ...

Obvykle má alespoň jednu abstraktní metodu, deklarovanou např.:

public abstract void vypisInfo() ...

Od a.t. nelze vytvořit instanci, nelze napsat např.:

Chovatel ch = new AbstraktniChovatel(...);

Viz Svět chovatelství z učebnice:

Pozn.: Obecný chovatel se ihned úplně implementovat nedá (ještě to neumíme), proto je definován jako abstraktní třída AbstraktniChovatel a teprve až ChovatelPsu je neabstraktní třída.

Je mnoho způsobů...

Postup:

Třída Zlomek používá assert k ověření, že zlomek není (chybou uživatele) vytvářen s nulovým jmenovatelem.

Za assert uvedeme, co musí v daném místě za běhu programu platit.

Obrázek 8.1. Třídy AssertDemo, Zlomek

Program přeložíme (s volbou -source 1.4):

Obrázek 8.2. Správný postup překladu AssertDemo

Program spustíme (s volbou -ea nebo selektivním -ea:NázevTřídy):

Obrázek 8.3. Spuštění AssertDemo s povolením assert

Spustíme-li bez povolení assert (bez volby -ea nebo naopak s explicitním zákazem: -da), pak program podmínky za assert neověřuje:

Obrázek 8.4. Spuštění AssertDemo bez povolení assert

Uvědomit si, že žádný nástroj za nás nevymyslí, JAK máme své třídy testovat. Pouze nám napomůže ke snadnějšímu sestavení a spuštění testu.

Postup:

Třída Zlomek zůstává zhruba jako v předchozím příkladu, přibývají však metody equals (porovnává dva zlomky, zda je jejich číselná hodnota stejná) a soucet (sečítá dva zlomky, součet vrací jako výsledek).

Obrázek 8.5. Upravená třída Zlomek s porovnáním a součtem

Testovací třída JUnitDemo má „přípravnou“ metodu setUp, tearDown a testovací metody.

Obrázek 8.6. Testovací třída JUnitDemo

Spuštění testovače v prostředí GUI Swing nad testovací třídou JUnitDemo.

Obrázek 8.7. Spouštění testovače nad testovací třídou JUnitDemo

Pokud testovací třída prověří, že testovaná třída/y je/jsou OK, vypadá to přibližně takto:

Obrázek 8.8. Testovač spouštějící třídu JUnitDemo

Má-li testovaná třída/y chyby a zjistí-li to testovač, vypadá to třeba takto:

Obrázek 8.9. Testovací třída JUnitDemo našla chybu

jass je preprocesor javového zdrojového textu. Umožňuje ve zdrojovém textu programu vyznačit podmínky, jejichž splnění je za běhu kontrolováno.

Podmínkami se rozumí:

Postup práce s jass:

Úloha je obdobou té předchozí.

Část Ia. Jde o to zmodifikovat třídy z předchozí úlohy, aby:

Jako společného předka těchto tříd v hierarchii dědičnosti použijte třídy AbstractSearcher, která bude (asi neúplně, protože je abstraktní) implementovat rozhraní Searcher.

Část Ib. Dále zmodifikujte třídyXXXMinMax z předchozí úlohy, aby:

Jak postupovat:

Část II. Na závěr reimplementujte (čili použijte a předělejte z úlohy 4.) do balíku cz.muni.fi.{vaslogin}.sorting2 také třídy BubbleSorter a QuickSorter tak, aby obě implementovaly rozhraní Sorter.

Při reimplementaci využijte společného abstraktního předka - třídu AbstractSorter, kterou si vytvoříte a umístíte do balíku cz.muni.fi.{vaslogin}.sorting2. Tato abstraktní třída bude částečně implementovat rozhraní Sorter - tj. bude implementovat ty metody, jež ve třídách BubbleSorter, QuickSorter vycházejí naprosto stejné.

Z praktických důvodů je vhodné nadeklarovat v této třídě například pomocnou metodu void swap(int i, int j), která prohodí v poli hodnoty na indexech i, j. Kontrolní otázka: Jaký přístupový modifikátor by tato metoda měla/mohla mít?

K reimplementovaným třídám sami vytvořte vhodné demo, které ukáže, že jsou funkční.

Obecné informace

Pozn: Pokud cvičící zadání modifikuje, je to OK. Tohle je vzorové zadání.

Za tyto úlohy dohromady získáte max. 5 bodů.

+, -, *, / a % (zbytek po celočíselném dělení)

logické součiny (AND):

logické součty (OR):

negace (NOT):

Tyto lze použít na porovnávání primitivních hodnot:

Test na rovnost/nerovnost lze použít na porovnávání primitivních hodnot i objektů:

Upozornění:

Použití ==

Chceme-li (intuitivně) chápat rovnost objektů podle obsahu, tj.

Příklad: objekt třídy Clovek nese informace o člověku. Dva objekty položíme stejné (rovnocenné), nesou-li stejná příjmení:

public class Clovek implements Comparable {
    String jmeno, prijmeni;
    public Clovek (String j, String p) {
        jmeno = j;
        prijmeni = p;
    }
    public boolean equals(Object o) {
        if (o instanceof Clovek) {
            Clovek c = (Clovek)o;
            return prijmeni.equals(c.prijmeni);
        } else
            throw new IllegalArgumentException(
            "Nelze porovnat objekt typu Clovek s objektem jineho typu");
    }
}

Méně agresivní verze by nemusela při porovnávání s jiným objektem než Clovek vyhodit výjimku, pouze vrátit false.

Jakmile u třídy překryjeme metodu equals, měli bychom současně překrýt objektů i metodu hashCode:

V těle hashCode s oblibou „přehráváme“ (delegujeme) řešení na volání hashCode jednotlivých složek objektu - a to těch, které figurují v equals:

public class Clovek implements Comparable {
    String jmeno, prijmeni;
    public Clovek (String j, String p) {
        jmeno = j;
        prijmeni = p;
    }
    public boolean equals(Object o) {
        if (o instanceof Clovek) {
            Clovek c = (Clovek)o;
            return prijmeni.equals(c.prijmeni);
        } else
            throw new IllegalArgumentException(
            "Nelze porovnat objekt typu Clovek s objektem jineho typu");
    }
    public int hashCode() {
         return prijmeni.hashCode();
    }
}

Bitové:

Posuny:

Dále viz např. Bitové operátory

Jediný ternární operátor

Platí-li první operand (má hodnotu true) ->

Typ prvního operandu musí být boolean, typy druhého a třetího musí být přiřaditelné do výsledku.

Výsledkem je vždy řetězec, ale argumenty mohou být i jiných typů, např.

sekvence int i = 1; System.out.println("promenna i="+i); je v pořádku

s řetězcovou konstantou se spojí řetězcová podoba dalších argumentů (např. čísla).

Pokud je argumentem zřetězení odkaz na objekt o ->

nejvyšší prioritu má násobení, dělení, nejnižší přiřazení