OOPR_03
1
Obsah přednášky • • • • • • • • •
Objektové datové typy Asociace mezi třídami Klíčové slovo final Třídní atributy a jejich využití Třídní metody Pravidla pro přetypování primitivních typů Metoda main Vytváření (generování) náhodných čísel Grafické prostředí - jednoduché grafické objekty. 2
Objektové datové typy • Objektové datové typy = třídy • Třídy knihoven a uživatelem definované třídy; standardní knihovna obsahuje cca 1500 tříd • metody a atributy musí být vždy v deklaraci třídy kvalifikované – musí být před nimi napsaný typ instance, primitivního typu
3
Vytvoření nové instance v instanční metodě a její vrácení • Vytvoření nové instance v metodě a její vrácení – operace s instancemi stejné třídy. • Primitivní operace (součet, rozdíl) datových atributů a vrácení výsledku v nové instanci. • Problém se vyskytuje v mnoha aplikacích. • Vysvětlíme na součtu komplexních čísel – třída Komp má datové atributy Re, Im – odpovídající přístupové a modifikační metody – metodu toString() a tisk()
4
Vytvoření nové instance v instanční metodě public class Komp { private int re, im; public Komp(int re, int im) { this.re = re; this.im = im) } public int getRe() { return re; } public Komp soucet(Komp in) { int nRe, nIm; nRe = getRe() + in.getRe(); nIm = getIm() + in.getIm(); return new Komp(nRe, nIm); } ... }
public class KompTest{ public staic void main(String[] args) { Komp k1 = new Komp(23, 12); Komp k2 = new Komp(-22, 14);
Komp v = k1.soucet(k2); } }
5
Asociace mezi třídami • Jednotlivé objekty nebo množiny stejných objektů (třídy) neexistují izolovaně, ale mají mezi sebou vazby – relace. • Relace umožňuje zachytit sémantický (významový) vztah mezi objekty nebo třídami objektů. • Asociace popisuje relace (vztahy) mezi třídami.
6
Asociace mezi třídami Objektové datové typy - použití
• Vytvoříme dvě třídy, z nichž jedna bude mít asociaci na druhou. • Třída Zakaznik, třída Ucet – má asociaci na třídu Zakaznik. • Vazba mezi třídami se realizuje prostřednictvím datového atributu dané třídy. • Implementace vazby mezi třídami se realizuje buď v přímo v konstruktoru, nebo konkrétní metodou - setZakaznik(). Přímý přístup není možný kvůli modifikátoru private. 7
Diagram tříd a diagram objektů UML asociace Zakaznik
«instantiate»
Ucet
«instantiate»
«instantiate»
zakaznik1
ucet3 spojení link
• asociace mezi třídami • spojení / link mezi objekty (zabaznik1, ucet3) • vazba instantiate mezi třídou a jejím objektem (instancí) 8
Syntaxe asociace název asociace
název role
vlastněný účet vlastník
vlastní
Zakaznik
Ucet 1
1
násobnost / kardinalita
• • • •
název asociace název role (rolí) násobnost / kardinalita průchodnost / směrování 9
public class Osoba { private String jmeno; private String bydliste;
Poznámky
public Osoba() { this("", ""); } public Osoba(String jmeno, String bydliste) { this.jmeno = jmeno; this.bydliste = bydliste; } }
10
Poznámky
public class Ucet { //odkaz na objektovy typ private Osoba vlastnik; private int stav; public Ucet() { this(null, 0); // vlastnik = null; }
stav = 0;
public Ucet(Osoba vlastnik, int castka) { this.vlastnik = vlastnik; stav = castka; } public void vlozeni(int castka){ setStav(getStav() + castka); } public void vyber(int castka) { setStav(getStav() – castka); }
//stav -= castka;
public void setVlastnik(Osoba zakaznik) { vlastnik = zakaznik; } }
11
public class UcZkTest { public static void main(String args[]) { Osoba zakaznik1 = new Osoba("Josef","Olomouc"); Osoba zakaznik2 = new Osoba("Ivana","Karvina"); Ucet ucet1 = new Ucet(zakaznik1, 200); Ucet ucet2 = new Ucet(zakaznik1, 500); Ucet ucet3 = new Ucet(zakaznik2, 400); ucet2.setVlastnik(zakaznik2); //ucet2.vlastnik = zakaznik2; nelze realizovat
Poznámky Datový atribut vlastnik má modifikátor private. Z jiné třídy je dostupný pouze pomocí přístupové metody.
} }
12
Objektové datové typy - grafické vyjádření Ucet
ucet1 zakaznik1 ucet2
zakaznik2 ucet3
-vlastnik -stav +vlozeni() +vyber()
Zakaznik -jmeno -bydliste
Ucet -vlastnik -stav +vlozeni() +vyber() Zakaznik
Ucet
-jmeno -bydliste
-vlastnik -stav +vlozeni() +vyber()
13
Přímá inicializace datových typů • Datové typy je možno inicializovat přímo v deklaraci: private int suma = 200; private String s1 = „libovolný řetězec“; private boolean q12 = true;
14
Klíčové slovo final • Význam klíčového slova final závisí na souvislostech a je v různých souvislostech různý. • obecně představuje neměnnost, nerozšiřitelnost • varianty: – – – – –
konstantní data konstantní argumenty prázdné konstanty konečné metody (spojitost s dědičností) konečné třídy (spojitost s dědičností) 15
Klíčové slovo final - konstantní data • užitečnost konstanty: – překladová konstanta, která nikdy nemění svoji hodnotu, – hodnota inicializovaná až za běhu programu, kterou nechceme měnit, – překladová konstanta, urychlí překlad (výpočty lze provádět již v době překladu), sníží zatížení běhu programu.
• v Javě smějí být konstanty pouze primitivních typů – vyjádřeny s klíčovým slovem final private final int TYDEN = 7; 16
Klíčové slovo final - konstantní data • private final int PRACTYDEN = 5;
• TYDEN má vždy hodnotu 7 • PRACTYDEN má vždy hodnotu 5 • Při použití klíčového slova final u odkazů na objekty způsobí, že odkaz (reference) bude neměnný!! • Proměnná již nemůže ukazovat na jiný objekt! • Datové atributy objektu měněny být mohou. 17
Poznámky
public class BodFinal { private final int x; private final int y; public BodFinal() { this(0, 0); } public BodFinal(int c) this(c, c); }
{
public BodFinal(int x, int y) this.x = x; this.y = y; }
{
public String toString() { String t = String.format("\nX: %d Y: %d“, getX(), getY()); return t; } public void tisk() { System.out.println("Souradnice bodu "+this.toString()); }
18
public int getX() { return x; }
public int getY(){ return y; } public void setX(int x){ //this.x = x; // can't assign a value to final variable x }
Poznámky U metod označených final překladač vypíše chybová hlášení
setX(), setY() a setBod()
public void setY(int y){ //this.y = y; // can't assign a value to final variable y } public void setBod(BodFinal a){ // x = a.x; can't assign a value to final variable x // y = a.y; can't assign a value to final variable y } public BodFinal getBod(){ return this; } }
19
Prázdné konstanty • Prázdné konstanty: – jsou datové složky deklarované jako final, kterým není přidělena žádná inicializační hodnota, – musí být ale inicializované před použitím (v konstruktoru), – umožňují, aby různé objekty měly různé hodnoty atributů final.
20
//Prazdne konstanty class Bod{ . . . }
public class Kruh{ final int NULA = 0; // inicializovana konstanta final double POLOMER; //prazdna konstanta final Bod stred; //prazdna konstanta – vzdy ukazuje na dany objekt
Poznámky Prázdné konstanty
public Kruh() { POLOMER = 25.5; stred = new Bod(); // inicializace v konstruktoru } public Kruh(double r, Bod b) { POLOMER = r; stred = new Bod(b); // kopirovaci konstruktor // inicializace v konstruktoru } public static void main(String[] args){ Kruh k1 = new Kruh(); Bod p = new Bod(26, 17); Kruh k2 = new Kruh(12.1, p); } }
21
Konstantní argumenty • Možnost deklarovat argumenty příslušných metod jako final – pak uvnitř metody nelze změnit hodnotu objektu.
22
public class KruhArg { public void operace(final Bod q){ //q = new Bod(); nelze menit Bod a = new Bod(); //q = a; nelze } public void operaceBez(Bod q){ q = new Bod(24,44); q.posun(20,60); } public int operaceP(final int i){ //i++; nelze menit return i+1; // je mozne } public Bod operaceX(Bod q){ //prekryti vstupniho argumentu q = new Bod(q); return q; }
Poznámky Konstantní argumenty
public static void main(String[] args) { Bod a = new Bod(10, 20); KruhArg ka = new KruhArg(); ka.operace(a); Bod x = ka.operaceX(a); a.tisk(); x.tisk(); if(a == x ) System.out.println("Jsou stejne"); else System.out.println("Nejsou stejne"); } }
23
Browser Javovských tříd • java.util – název paketu java.util.*; java.util.Scanner; • Scanner je název konkrétní třídy • Základní třídy: String, System jsou uloženy v java.lang paketu, který je importován implicitně. • Existuje speciální vztah mezi třídami umístěnými ve stejném adresáři na disku: Bod, BodTest Implicitně jsou takové třídy považovány za třídy jednoho paketu, uváděného jako default package. 24
Browser Javovských tříd • Třídy ve stejném paketu jsou implicitně importovány do zdrojového kódu jiných tříd ve stejném paketu. • Proto není třeba deklarace import, když jedna třída paketu používá jinou třídu stejného paketu. • Deklarace import plně kvalifikuje jména použitých tříd z jiného paketu.
25
Lokální proměnné • V deklaraci třídy jsou datové atributy a metody. • Lokální proměnné jsou dočasné proměnné deklarované: – uvnitř metod (v těle metod), – nesmí se používat modifikátory přístupu (private, public) ani modifikátor static, – platnost je pouze v rámci dané metody, – před prvním použitím vyžadují přiřadit nějakou hodnotu – tím se liší od datových atributů, – při opuštění metody se lokální proměnné zruší, při příštím spuštění metody se znovu vytvoří.
26
Lokální proměnné public soucet(int A, int B, int C) { int pom = 0; pom = A + B + C; return pom; }
27
Třídní a instanční proměnné • Instanční proměnné jsou datové atributy objektu. Jejich hodnoty, reference se většinou liší. • Třídní proměnné jsou proměnné třídy – hodnoty stejné pro všechny objekty (instance) dané třídy. • Klíčové slovo static je uvedeno před datovým / objektovým typem. • Notace zápisu: private static int cislo; private static String nazev;
28
Třídní a instanční proměnné • Třídní proměnné zabezpečí pouze jedno „úložiště“ dané třídní proměnné pro všechny objekty dané třídy • Třídní metoda není přidružena k žádnému konkrétnímu objektu třídy. • Bez vytvoření objektu je možné přistupovat k třídním metodám dané třídy a jejich prostřednictvím k třídním atributům.
29
public class StaticTest { private static int i = 47; public static int getI(){ return i; } public void setI(int j){ i = j; }
Poznámky StaticTest
public static void main(String[] args) { StaticTest st1 = new StaticTest(); StaticTest st2 = new StaticTest(); st1.i++; StaticTest.i++; System.out.println("Hodnota i:"+st2.i); System.out.println("Hodnota i: "+st2.getI()); System.out.println("Hodnota i - trida prijemce: "+ StaticTest.getI()); } }
Hodnota i:49 Hodnota i: 49 Hodnota i - trida prijemce: 49
30
Využití třídních (statických) proměnných • V rámci dané třídy jako „globální” proměnné dostupné všem objektům dané třídy. • Třída Bod: private static int krokX = 50; private static int krokY = 120; public void move() { x = x + krokX; y = y + krokY; } 31
Atributy objektů & atributy třídy • Atributy objektů (instancí) je možné inicializovat buď přímo v deklaraci, nebo později v konstruktoru. • Atributy tříd (třídní atributy) možno inicializovat přímo v deklaraci, nebo prostřednictvím třídních přístupových a modifikačních metod.
32
Třídní & instanční metody • Instanční metody – aplikují se na objekty. • Třídní metody (metody třídy) se aplikují na danou třídu, zajišťují (nastavují) hodnoty atributů třídy. – definují se vložením klíčového slova static mezi identifikátory, – mají platnost pro všechny instance (objekty) dané třídy, – mohou být volány před vznikem instance dané třídy, 33
Třídní metody – slouží k přípravě prostředí ve kterém vznikne objekt. – slouží k definici metod, které nejsou vázány na žádnou instanci (objekt) - takto jsou definovány matematické funkce.
34
Třídní metody • Metody třídy (Class methods) nezávisí na žádné instanci. V metodách třídy tedy nemůžeme: – používat metody a atributy instancí – přesněji atributy a metody instancí kvalifikované klíčovým slovem this, – překladač totiž nemá žádnou informaci, která instance by se za klíčovým slovem this mohla v daném okamžiku skrývat.
35
Poznámky
public class BodStatic { private int x; private int y; private String jmeno; private static int krokX = 25; private static int krokY = -40; public BodStatic(String j) { this(j, 0, 0); } public BodStatic(String j, int c) this(j, c, c); }
{
public BodStatic(String j, int x, int y) { this.x = x; this.y = y; jmeno = j; } public String toString() { String t = String.format("\n%11s %4s %4s %4d %4s %4d","Nazev bodu:", getJmeno(),"X:",getX(),"Y:",getY()); return t; } public void tisk() { System.out.printf(this.toString()); }
36
public int getX() { return x; }
Poznámky
public int getY(){ return y; } public void setX(int x){ this.x = x; } public void setY(int y){ this.y = y; } public void setBod(BodStatic a){ setX(a.getX()); setY(a.getY()); } public String getJmeno(){ return jmeno; }
public BodStatic getBodStatic(){ return this; } public void posunX(){ x =+ krokX; } public void posunY(){ y =+ krokY; } public void posunXY(){ posunX(); this.posunY(); // pouziti (nepouziti) this nehraje roli } }
37
public class BodStaticTest { public static void main(String args[]){ BodStatic a, b, c; a = new BodStatic("a"); a.tisk(); b = new BodStatic("b",-10, 122); b.tisk(); c = b.getBodStatic(); c.tisk(); a.posunX(); a.tisk(); b.posunY(); b.tisk(); c.posunXY(); c.tisk(); } }
Poznámky BodStaticTest
38
Metody třídy Math Metoda
Popis
Příklad
abs(x)
absolutní hodnota
abs(-27.3) = 27.3
ceil(x)
Zaokrouhlí x na celé číslo větší než x
ceil(9.2) = 10.0
ceil(-9.2) = -9
cos(x)
x je v radianech
cos(0.0) = 1.0
exp(x)
exponenciální funkce
exp(1.0) = 2.71828
floor(x)
zaokrouhlí x na celé číslo menší než x
floor(9.2) = 9.0 floor(-9.8) = -10.0
log(x)
funkce přirozeného logaritmu
log(Math.E) = 1.0
max(x, y)
vrací větší z x a y
max(12.3, 14.2)
min(x, y)
vrací menší z x a y
min(16.9, -33)
pow(x, y)
umocní x na y
pow(2.0, 7.0) = 128.0
sin(x)
x je v radiánech
sin(0.0) = 0.0
sqrt(x)
druhá odmocnina
sqrt(900.0) = 30.0
tan(x)
x je v radiánech
tan(0.0) = 0.0
39
Metody třídy Math • Třída Math obsahuje konstanty Math.PI a Math.E
40
Přetypování primitivních typů • Automatické přetypování argumentů (parametrů) metod – Přinutí argumenty ke konverzi na vhodné typy při jejich předávání do metod • např. System.out.println( Math.sqrt( 4 ) ); – Vypočítá Math.sqrt( 4 ) – Pak vyhodnotí System.out.println()
• Pravidla převodu – Určují, jak převádět automaticky primitivní typy bez ztráty dat. 41
Tabulka možností automatického přetypování primitivních typů Typ
Možné přetypování
double
None
float
double
long
float or double
int
long, float or double
char
int, long, float or double
short
int, long, float or double (but not char)
bype
short, int, long, float, or double (but not char)
boolean
None (boolean hodnoty nejsou v Javě považovány za čísla) 42
Main metoda • Metoda main – deklarovaná jako static • Deklarací metody main jako static umožňuje JVM vyvolat metodu main bez vytváření instance této třídy. public static void main(String[] args)
java ClassName arg1 arg2 …// běh aplikace
• JVM nahrává specifikovanou třídu (ClassName) a vyvolává metodu main této třídy. Proto je metoda main třídní.
43
Třídní metody • Podobně jako existuje třída Math, může existovat jinak uživatelsky deklarovaná třída s třídními metodami • Tato třída slouží pouze jako „schránka“ pro různé třídní metody
44
import javax.swing.JOptionPane; // Class static pomocna trida slouzici jako schranka pro staticke metody public class Cs { // private konstruktor nedovoli vytvaret instance od dane tridy private Cs() { }
Poznámky Třída Cs
// spocte delku usecky se zadanymi krajnimi body public static double delka(double x1, double y1, double x2, double y2) { double dx = x2 - x1; double dy = y2 - y1; if (dx < 0 || dy < 0) return 0.0; else return Cs.prepona(dx,dy); } // spocte delku pravouhleho trojuhelnika se zadanymi odvesnami public static double prepona(double x, double y) { return Math.sqrt(x*x + y*y); } // vraci pouze nazev tridy zadane instance bez nazvu balicku public static String nazevTridy(Object o) { // getClass() vraci class a getName() vraci retezec String trida = o.getClass().getName(); return Cs.pouzeNazev(trida); }
45
// vraci pouze nazev tridy, bez nazvu balicku // balicek.trida - vraci od '.' do konce retezce public static String pouzeNazev(String nazev) { int p = nazev.lastIndexOf('.'); p = p + 1; //retezce se pocitaji od nuly return nazev.substring(p); } // dialogove okno se zpravou pro odpoved uzivatele // ANO, NE, STORNO vrati informaci jak uzivatel odpovedel // STORNO - uzavre dialog a ukonci program public static boolean souhlas(Object dotaz) { return souhlas("Dotaz", dotaz); } // zobrazi dialogove okno a umozni uzivateli odpovedet // ANO, NE, STORNO public static boolean souhlas(String nadpis, Object dotaz) { int odpoved = JOptionPane.showOptionDialog( null, //rodicivska komponenta neni - vystredi na obrazovce dotaz, //otazka na kterou ma uzivatel odpovedet nadpis, //titulek okna 0, //nula - volitelny typ JOptionPane.QUESTION_MESSAGE, //typ zpravy Message type null, //icon new Object[] { "Ano", "Ne", "Storno"}, "Ano" // implicitni hodnota );
Poznámky Třída Cs
46
if ((odpoved == JOptionPane.CANCEL_OPTION) || (odpoved == JOptionPane.CLOSED_OPTION)) { System.exit(0); } return (odpoved == JOptionPane.YES_OPTION); } // dialogove okno s vyzvou k zadani realne hodnoty, kterou vraci // pri zavreni okna, nebo cancel se ukonci aplikace // @param vyzva - text, ktery se zibrazi // @param doubleImpl - implicitni hodnota public static double zadej(Object vyzva, double doubleImpl) { return Double.parseDouble( zadej(vyzva, ""+doubleImpl ).trim() ); } // vraci cele cislo, nebo implicitni hodnotu public static int zadej(Object vyzva, int intImpl) { return Integer.parseInt( zadej( vyzva, ""+intImpl). trim() ); } // vraci retezec nebo implicitni hodnotu public static String zadej(Object vyzva, String stringImpl) { String odpoved = JOptionPane.showInputDialog(null, vyzva, stringImpl); if (odpoved == null) System.exit(0); return odpoved; }
Poznámky Třída Cs
47
// zobrazi dialogove okno se zpravou a pocka, az je uzivatel odklepne public static void zprava( Object text) { int odpoved = JOptionPane.showConfirmDialog( null, // rodicovska komponenta neni - vystredi se na obrazovce text, //zprava sdelovana uzivateli "Zprava", //titulek okna JOptionPane.DEFAULT_OPTION, //volitelny typ OK JOptionPane.INFORMATION_MESSAGE //Message type ); if (odpoved == JOptionPane.CLOSED_OPTION) System.exit(0); }
Poznámky Třída Cs
}
48
public class IOTest { private IOTest() { }
Poznámky
public static Osoba jmenoNarozeni() { String jmeno = Cs.zadej("Zadejte sve jmeno:", "Adam"); int rokNarozeni = Cs.zadej("Zadejte rok narozeni:", 1900); Cs.zprava("Vase jmeno: "+jmeno+"\nVas rok narozeni: "+rokNarozeni); Osoba o1= new Osoba(); o1.setJmeno(jmeno); o1.setRokNarozeni(rokNarozeni); return o1; } // celociselne deleni public static int celociselneDeleni() { int delenec = Cs.zadej("Delenec (cele cislo):", 0); int delitel = Cs.zadej("Delitel (cele cislo):", 1); int podil = delenec / delitel; int zbytek = delenec % delitel; Cs.zprava(delenec +" : "+delitel+ " = " +podil + " zbytek " + zbytek); return podil; }
49
// deleni realnych cisel public static double realneDeleni() { double delenec = Cs.zadej("Delenec :", 0); double delitel = Cs.zadej("Delitel :", 1); double podil = delenec / delitel; double zbytek = delenec % delitel; Cs.zprava(delenec +" : "+delitel+ " = " +podil + "\nzbytek "+ zbytek); return podil; } }
Poznámky
50
public class OsobaTest { public static void main(String[] args) { Cs.zprava("Start aplikace"); String jmeno = Cs.zadej("Jmeno","neuvedeno"); int rokN = Cs.zadej("Rok narozeni",1900); String ulice = Cs.zadej("Nazev ulice","nezadana"); int cisloD = Cs.zadej("Cislo domu",0); String mesto = Cs.zadej("Mesto","nezadane"); Osoba o1 = new Osoba(jmeno, rokN, new Adresa(ulice, cisloD, mesto)); int cislo = Cs.zadej("Cislo uctu",0); int stav = Cs.zadej("Pocatecni stav uctu",0);
Poznámky OsobaTest
Ucet u1 = new Ucet(cislo, stav); o1.setUcet(u1); // neni mozne o1.ucet = u1; boolean q = true;
51
while (q) { String odp = Cs.zadej("Prehled operaci:\n"+ "v,V - vlozeni\n"+"w, W - vyber\n"+ "t,T - tisk ucet\n"+"p,P - tisk osoba\n"+ "k,K - konec operaci","k"); char ch = odp.charAt(0); switch (ch) { case 'v': case 'V': int castka = Cs.zadej("Vkladana castka",0); o1.vlozeni(castka); break; case 'w': case 'W': int castka1 = Cs.zadej("Vybirana castka",0); o1.vyber(castka1); break; case 't': case 'T': o1.getUcet().tisk(); break; case 'p': case 'P': o1.tisk(); break; case 'k': case 'K': q = false; break; default: boolean qx = Cs.souhlas("Zadali jste spatnou odpoved\n"+ "Chcete pokracovat?"); q = qx; break; } } Cs.zprava("Konec programu"); }
Poznámky OsobaTest
}
52
Jednoduché grafické objekty bod, čára • Grafické prostředí tvoří třídy BaseCanvas.java a Gui.java. • Třída Bod – nutnost doplnit o další datové atributy a metody.
53
import java.awt.Color; 1 public class Bod { 2 private int x; 3 private int y; 4 private Color barva; 5 private BaseCanvas obraz = Gui.getInstance().getCanvas(); 6 private Color barvaPozadi = Color.white; 7 public Bod() { 8 this(0, 0, Color.red); 9 } 10 public Bod(int x, int y) { 11 this(x, y, Color.red); 12 } 13 14 15 16 17
public Bod(int x, int y, Color barva) { this.x = x; this.y = y; this.barva = barva; }
18 19 20 21
public Bod(int x, int y, String barva) { this.x = x; this.y = y; this.barva = this.stringToColor(barva); }
Poznámky
54
22 // kopirovaci konstruktor 23 public Bod(Bod bod) { 24 x = bod.getX(); 25 y = bod.getY(); 26 barva = bod.getBarva(); 27 } ...
Poznámky
55
import java.awt.Color; public class Barva { public static Color cerna() { return Color.black; } public static Color cervena() { return Color.red; } public static Color modra() { return Color.blue; } public static Color zelena() { return Color.green; } public static Color zluta() { return Color.yellow; } . . . }
Poznámky Barva.cervena() Color.red Barva.zluta() Color.yellow
56
28 29 30
public Color getBarva() { return barva; }
Poznámky Třída Bod – 2. část
31 32 33 34 35 36
public BaseCanvas getObraz() { return obraz; } public Color getBarvaPozadi() { return barvaPozadi; }
37 38 39
public void setBarva(Color barva) { this.barva = barva; }
40 41 42 43 44
public void vykresli() { getObraz().putPixel(getX(), getY(), getBarva()); } public void smaz() { getObraz().putPixel(getX(), getY(), getBarvaPozadi()); }
45
57
47 48
49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67
public void vykresli(int x1, int y1) { getObraz().putPixel(getX() + x1, getY() + y1, getBarva()); }
Poznámky
public void smaz(int x1, int y1) { getObraz().putPixel(getX() + x1, getY() + y1, getBarvaPozadi()); }
public void posunSouradnic(int dx, int dy) { setX(getX() + dx); setY(getY() + dy); } public void posunBod(int dx, int dy) { this.smaz(); this.posunSouradnic(dx, dy); this.vykresli(); } public String toString(){ return "X: " + getX() + " Y: " + getY() + " barva: " + getBarva(); }
58
68 69 70
public void tisk() { System.out.println(toString()); }
71 72 73 74 75 76 77 78
public void pauza(int doba) { try { Thread vlakno = new Thread(); vlakno.sleep(doba); } catch(InterruptedException e) { System.out.println("Chyba vlakno pauza"); } }
79 80 81 82 83 84 85 86 87 88
Poznámky
public Color stringToColor(String barva) { switch(barva) { case "cerna": return Color.black; case "cervena": return Color.red; case "modra": return Color.blue; case "zelena": return Color.green; case "ruzova": return Color.pink; default: return Color.red; } }
59
89 90 91
public int delkaX(Bod bod) { return Math.abs(getX() - bod.getX()); }
Poznámky
92 public int delkaY(Bod bod) { 93 return Math.abs(getY() - bod.getY()); 94 } 95 }
60
import java.awt.Color; public class BodTest { public static void main(String[] args) { Bod bodA = new Bod(100,110, Color.red); Bod bodB = new Bod(230, 400, "modra"); // vykresleni 4x bodA bodA.vykresli(); bodA.vykresli(0, 1); bodA.vykresli(0, 2); bodA.vykresli(0, 3); bodA.pauza(20);
Poznámky
// vykresleni 3x bodB bodB.vykresli(); bodB.posunSouradnic(1, 0); bodB.vykresli(); bodB.posunSouradnic(1, 0); bodB.vykresli(); bodB.pauza(20); bodA.posunSouradnic(40, 50); // vykresleni svisle cary for(int i = 0; i < 200; i++) { bodA.vykresli(0, i); bodA.pauza(40); } bodB.posunBod(30, 20); . . . }
61
Případová studie: Generování náhodných čísel • náhodná čísla v dané rozsahu 1 – 100 • testování jejich vhodnosti • transformace na různé typy statistických rozložení
• Java – třída Random – z paketu java.util, nebo - statická metoda random() třídy Math – paket java.lang • produkuje čísla typu double v rozsahu 0.0 <= x < 1.0 62
Generování náhodných čísel • vytvoření objektu a jeho použití
Random nahodneCislo = new Random(); int nahodnaHodnota = nahodneCislo.nextInt(); • metoda nextInt() vytvoří náhodné číslo v rozsahu: -2 147 483 648 +2 147 483 647 • mluvíme o takzvaných pseudonáhodných číslech. 63
Generování náhodných čísel házení kostkou int nahodnaHodnota = nahodneCislo.nextInt(2); //vrací hodnoty 0 a 1 int hod= nahodneCislo.nextInt(6); //vrací hodnopty od 0 do 5 int hod = 1 + nahodneCislo.nextInt(6);
64
// Shifted and scaled random integers. import java.util.Random; // program uses class Random
Poznámky
public class RandomIntegers { public static void main( String args[] ) { Random randomNumbers = new Random(); // random number generator int face; // stores each random integer generated // loop 20 times for ( int counter = 1; counter <= 20; counter++ ) { // pick random integer from 1 to 6 face = 1 + randomNumbers.nextInt( 6 ); System.out.printf( "%d
", face ); // display generated value
// if counter is divisible by 5, start a new line of output if ( counter % 5 == 0 ) System.out.println(); } // end for } // end main } // end class RandomIntegers
65
6 2 6 6
4 2 1 3
6 1 1 3
6 5 1 6
3 4 2 4
4 5 3 1
1 2 4 6
5 5 4 1
2 2 6 2
3 3 5 3
Poznámky Výsledky generování
66
Poznámky
// Roll a six-sided die 6000 times. import java.util.Random;
public class RollDie { public static void main( String args[] ) { Random randomNumbers = new Random(); // random number generator int int int int int int
frequency1 frequency2 frequency3 frequency4 frequency5 frequency6
= = = = = =
0; 0; 0; 0; 0; 0;
// // // // // //
count count count count count count
of of of of of of
1s 2s 3s 4s 5s 6s
rolled rolled rolled rolled rolled rolled
int face; // stores most recently rolled value // summarize results of 6000 rolls of a die for ( int roll = 1; roll <= 6000; roll++ ) { face = 1 + randomNumbers.nextInt( 6 ); // number from 1 to 6
67
// determine roll value 1-6 and increment appropriate counter switch ( face ) { case 1: ++frequency1; // increment the 1s counter break; case 2: ++frequency2; // increment the 2s counter break; case 3: ++frequency3; // increment the 3s counter break; case 4: ++frequency4; // increment the 4s counter break; case 5: ++frequency5; // increment the 5s counter break; case 6: ++frequency6; // increment the 6s counter break; // optional at end of switch } // end switch } // end for
Poznámky
System.out.println( "Face\tFrequency" ); // output headers System.out.printf( "1\t%d\n2\t%d\n3\t%d\n4\t%d\n5\t%d\n6\t%d\n", frequency1, frequency2, frequency3, frequency4, frequency5, frequency6 ); } // end main } // end class RollDie
68
Face 1 2 3 4 5 6
Frequency 1047 1009 953 992 988 1011
Face 1 2 3 4 5 6
Frequency 1043 980 972 974 1004 1027
Poznámky Výsledky programu
69
