Java - trieda Ratio - História úprav

Pf na 05:34, 16. február 2011

2011-02-16T05:34:28Z

Juraj na 15:41, 5. september 2010

2010-09-05T15:41:00Z

Juraj: Vytváranie vlastných tried premiestnená na Java - trieda Ratio

2010-09-05T15:24:04Z

Vytváranie vlastných tried premiestnená na Java - trieda Ratio

Pf na 21:27, 7. marec 2010

2010-03-07T21:27:22Z

Pf na 21:19, 7. marec 2010

2010-03-07T21:19:40Z

Pf: /* Tunning triedy Ratio */

2010-03-07T21:17:29Z

Tunning triedy Ratio

Pf: Vytvorená stránka „NOTOC Category:Java Aj keď Java obsahuje obrovské množstvo hotových tried z najrozličnejších oblastí (celá kolekcia tried je označovaná ako Java Platform…“

2010-03-07T21:08:56Z

Vytvorená stránka „__NOTOC__ Category:Java Aj keď Java obsahuje obrovské množstvo hotových tried z najrozličnejších oblastí (celá kolekcia tried je označovaná ako Java Platform…“

Nová stránka

__NOTOC__
[[Category:Java]]
Aj keď Java obsahuje obrovské množstvo hotových tried z najrozličnejších oblastí (celá kolekcia tried je označovaná ako Java Platform), pri riešení špecifických problémov musíme vytvárať vlastné triedy. Naše triedy môžu samozrejme pracovať a využívať hotové triedy Javy ako aj iné naše vlastné triedy. Predstavme si, že sme postavení pred úlohu, pre našeho známeho, ktorý sa zaoberá numerickou matematikou, vytvoriť triedu, ktorá bude simulovať počítanie s racionálnymi číslami, t.j. číslami, ktoré sa dajú zobraziť pomocou celočíselného zlomku. Napriek tomu, že saa Vám môže zdať táto úloha dosť bizardná, treba si uvedomiť, že takúto triedu môžeme využiť aj napr. pri testovaní a tvorbe algoritmov pre malé mikrokontroléry, ktroré poznajú len celočíselnú aritmetiku.

== Trieda Ratio ==
Pri návrhu našej triedy vychádzajme z vyšššie uvedenej 'špecifikácie'. Trieda bude obsahovať celočíselné (int) atribúty ''cit'' a ''men'', ktoré budú reprezentovať čitateľ a menovateľ zlomku. Zároveň vytvoríme aj sadu konštruktorov pre inicializáciu našich objektov. Objekty (buducej) triedy '''Ratio''' chceme vytvárať nasledujúcimi spôsobmi
<source lang="java">
Ratio x=new Ratio(); // vytvori objekt 0/1
Ratio y=new Ratio(5); // vytvori objekt 5/1
Ratio z=new Ratio(3,4); // vytvori objekt 3/4
</source>
Základom triedy '''Ratio''' potom bude nasledujúca konštrukcia, v ktorej zadefinujeme dátovú štruktúru triedy a potrebné konštruktory. Treba si uvedomiť, že konštruktor ''Ratio()'' prekrýva štandardný konštruktor triedy, ktorý inicializuje objekt s default hodnotami premenných, v našom prípade by bol čitateľ aj menovateľ inicializovaný hodnotou 0.
<source lang="java">
public class Ratio {
int cit; //bez public - default visibility
int men; //skryté pre iné balíky

public Ratio() { //konštruktor prekrývajúci default konštr.
cit = 0;
men = 1; //defaultne by menovateľ bol 0
}

public Ratio(int cit) { //konštruktor definujúci len čitateľ
this.cit = cit;
men = 1;
}

public Ratio(int cit, int men) { //štand. konštruktor
this.cit = cit;
this.men = men;
}
}
</source>

Modifikátor ''public'' pred deklaráciou konštruktora znamená, že uvedený konštruktor a/alebo metódu môže zavolať (používať) ľubovolná iná časť kódu Vašeho programu. Metódy a premenné, ktoré takto ozanačené nie sú, môže pouzívať len kód triedy samotnej (pomocné metódy a pod.) alebo v hierarchii dedenia (vysvetleneé neskôr) potomkovia triedy.

Samozrejme, takáto trieda nie je v tomto stave použiteľná pre reálne počítanie. Musíme ju doplniť metódami, ktoré nám minimálne umožnia racionálne čísla spočítať, odčítať, deliť a násobiť.

== Metódy triedy Ratio ==
Prvou z metód, ktorými potrebujeme našu triedu doplniť, je metóda, pomocou ktorej si môžeme naše objekty zobrazit (vytlačiť) v tvare zlomku

<source lang="java">
public class Ratio {
...
public void tlac() { //len výpis
System.out.println(cit + " / " + men);
}
...
}
</source>

Matematické metódy doplníme tak, aby implementovali všeobecne známe pravidlá pre počítanie s racionálnymi číslami. Musíme si uvedomiť, že operácia spočítania dvoch čísel (všeobecne) nemení hodnotu oboch sčítancov, takže výsledkom súčtu je '''nove''' číslo.
Pre spočítanie dvoch racionálnych čísel vytvoríme metódu ''add'', obdobným spôsobom (pre rešpektovaní matematických pravidiel) si vytvoríte aj ďalšie metódy.

<source lang="java">
public class Ratio {
...
public Ratio add(Ratio b) {
int tmpcit = cit*b.men + men*b.cit;
int tmpmen = men*b.men;

return new Ratio(tmpcit,tmpmen);
...
}
</source>
Našu triedu '''Ratio''' už môžeme otestovať. K tomuto vytvoríme triedu '''TestRatio''', v ktorej si napíšeme krátky test triedy

<source lang="java">
public class TestRatio {
public static void main(String[] args) {
Ratio a = new Ratio(2,3), b = new Ratio(1,3), c = new Ratio();

a.tlac(); // kontrolný výpis
b.tlac(); // kontrolný výpis
c=a.add(b); // príkaz pripočítania
System.out.println();
a.tlac(); // kontrolný výpis
b.tlac(); // kontrolný výpis
c.tlac(); // výsledok
}
}
</source>

== Tunning triedy Ratio ==
Naśu triedu '''Ratio''' (po doplnení ostatnými metódami) už môžeme používať, nie je ale zatial 'kompatibilná' s ostatnými metódami javy, napr. nemôžeme v programe našu triedu použiť ako argument metódy pre štandardný výstup ''System.out.println()''.
Aby sme mohli našu triedu používať ako bežnú triedu, premenujeme metódu ''tlac()'' na metódu ''toString()''. Táto metóda je volaná automaticky pri tlačení objektov na konzolu a môžeme v nej zadefinovať nami zvolenú textovú reprezentáciu objektu.
<source lang="java">
System.out.println("a= " + a);
</source>
Druhým problémom našej triedy je, že po každej matematickej operácii nám narastá numerická hodnota čitateľa aj menovateľa a teoreticky sa môžeme po nejakej dobe dostať k limitným hodnotám pre dátový typ určujúci ich numerický rozsah. Zmena dátového typu na väčší tento problém neodstráni, len potenciálne oddiali. Riešením je po každej numerickej operácii predeliť čitateľa aj menovateľa najväčším spoločným deliteľom a tým uržiavať čitateľa aj menovateľa na minimálnej možnej numerickej hodnote.

@@ Riadok 1: / Riadok 1: @@
 {{Navigacne menu - java}}
 __TOC__
-Aj keď Java obsahuje obrovské množstvo hotových tried z najrozličnejších oblastí (celá kolekcia tried je označovaná ako Java Platform), pri riešení špecifických problémov musíme vytvárať vlastné triedy. Naše triedy môžu samozrejme pracovať a využívať hotové triedy Javy ako aj iné naše vlastné triedy. Predstavme si, že sme postavení pred úlohu, pre našeho známeho, ktorý sa zaoberá numerickou matematikou, vytvoriť triedu, ktorá bude simulovať počítanie s racionálnymi číslami, t.j. číslami, ktoré sa dajú zobraziť pomocou celočíselného zlomku. Napriek tomu, že saa Vám môže zdať táto úloha dosť bizardná, treba si uvedomiť, že takúto triedu môžeme využiť aj napr. pri testovaní a tvorbe algoritmov pre malé mikrokontroléry, ktroré poznajú len celočíselnú aritmetiku. Okrem toho matematici milujú racionálne čísla, pretože sa s nimi dá počítať bez straty presnosti, napr. 1/3 je jednoducho presne jedna tretina a nie 0.3333333. Pri každom type počítania s definovaným rozsahom vždy narazíme na konrčnú presnosť, skúste si na ľubovolnej kalkulačke spočítať (1/3)+(1/3)+(1/3)-1.
+Aj keď Java obsahuje obrovské množstvo hotových tried z najrozličnejších oblastí (celá kolekcia tried je označovaná ako Java Platform), pri riešení špecifických problémov musíme vytvárať vlastné triedy. Naše triedy môžu samozrejme pracovať a využívať hotové triedy Javy ako aj iné naše vlastné triedy. Predstavme si, že sme postavení pred úlohu, pre našeho známeho, ktorý sa zaoberá numerickou matematikou, vytvoriť triedu, ktorá bude simulovať počítanie s racionálnymi číslami, t.j. číslami, ktoré sa dajú zobraziť pomocou celočíselného zlomku. Napriek tomu, že sa Vám môže zdať táto úloha dosť bizardná, treba si uvedomiť, že takúto triedu môžeme využiť aj napr. pri testovaní a tvorbe algoritmov pre malé mikrokontroléry, ktroré poznajú len celočíselnú aritmetiku. Okrem toho matematici milujú racionálne čísla, pretože sa s nimi dá počítať bez straty presnosti, napr. 1/3 je jednoducho presne jedna tretina a nie 0.3333333. Pri každom type počítania s definovaným rozsahom vždy narazíme na konečnú presnosť, skúste si preto na ľubovolnej kalkulačke spočítať (1/3)+(1/3)+(1/3)-1.
 == Trieda Ratio ==

← Staršia verzia		Verzia zo dňa a času 21:19, 7. marec 2010
Riadok 104:		Riadok 104:
	</source>		</source>

−	Celý zdrojový text triedy	+	Celý zdrojový text triedy '''Ratio''' má potom tvar
		+	<source lang="java">
		+	public class Ratio {
		+	private int cit; //skryté
		+	private int men; //skryté
		+
		+	public Ratio() { //konštruktor prekrývajúci default konštr.
		+	cit = 0;
		+	men = 1; //defaultne by menovateľ bol 0
		+	}
		+
		+	public Ratio(int cit) { //konštruktor definujúci len čitateľ
		+	this.cit = cit;
		+	men = 1;
		+	}
		+
		+	public Ratio(int cit, int men) { //štand. konštruktor
		+	this.cit = cit;
		+	this.men = men;
		+	}
		+
		+	public String toString() { //vracia reťazec
		+	String s;
		+	s = cit + " / " + men; //cit a men sa pretypujú na String
		+	return s;
		+	}
		+
		+	void nsd() { //prevod do základného tvaru
		+	int i = cit, j = men;
		+
		+	while(j!=0) { int k=i%j; i=j; j=k; }
		+
		+	cit = cit/Math.abs(i);
		+	men = men/Math.abs(i);
		+	}
		+
		+	public Ratio add(Ratio b) { //sčítanie
		+	int tmpcit = citb.men + menb.cit;
		+	int tmpmen = men*b.men;
		+
		+	Ratio n = new Ratio(tmpcit,tmpmen);
		+	n.nsd();
		+	return n;
		+	}
		+
		+	public Ratio sub(Ratio b) { //odčítanie
		+	int tmpcit = citb.men - menb.cit;
		+	int tmpmen = men*b.men;
		+
		+	Ratio n = new Ratio(tmpcit,tmpmen);
		+	n.nsd();
		+	return n;
		+	}
		+
		+	public Ratio mul(Ratio b) { //násobenie
		+	int tmpcit = cit*b.cit;
		+	int tmpmen = men*b.men;
		+
		+	Ratio n = new Ratio(tmpcit,tmpmen);
		+	n.nsd();
		+	return n;
		+	}
		+
		+	public Ratio div(Ratio b) { //delenie
		+	int tmpcit = cit*b.men;
		+	int tmpmen = men*b.cit;
		+
		+	Ratio n = new Ratio(tmpcit,tmpmen);
		+	n.nsd();
		+	return n;
		+	}
		+
		+	public int trunc() { //celá časť čísla
		+	return cit/men; //celočíselné delenie
		+	}
		+	}
		+	</source>

@@ Riadok 1: / Riadok 1: @@
-__NOTOC__
+{{Navigacne menu - java}}
-[[Category:Java]]
+__TOC__
 Aj keď Java obsahuje obrovské množstvo hotových tried z najrozličnejších oblastí (celá kolekcia tried je označovaná ako Java Platform), pri riešení špecifických problémov musíme vytvárať vlastné triedy. Naše triedy môžu samozrejme pracovať a využívať hotové triedy Javy ako aj iné naše vlastné triedy. Predstavme si, že sme postavení pred úlohu, pre našeho známeho, ktorý sa zaoberá numerickou matematikou, vytvoriť triedu, ktorá bude simulovať počítanie s racionálnymi číslami, t.j. číslami, ktoré sa dajú zobraziť pomocou celočíselného zlomku. Napriek tomu, že saa Vám môže zdať táto úloha dosť bizardná, treba si uvedomiť, že takúto triedu môžeme využiť aj napr. pri testovaní a tvorbe algoritmov pre malé mikrokontroléry, ktroré poznajú len celočíselnú aritmetiku. Okrem toho matematici milujú racionálne čísla, pretože sa s nimi dá počítať bez straty presnosti, napr. 1/3 je jednoducho presne jedna tretina a nie 0.3333333. Pri každom type počítania s definovaným rozsahom vždy narazíme na konrčnú presnosť, skúste si na ľubovolnej kalkulačke spočítať (1/3)+(1/3)+(1/3)-1.
@@ Riadok 37: / Riadok 37: @@
 Samozrejme, takáto trieda nie je v tomto stave použiteľná pre reálne počítanie. Musíme ju doplniť metódami, ktoré nám minimálne umožnia racionálne čísla spočítať, odčítať, deliť a násobiť.
-== Metódy triedy Ratio ==
+=== Metódy triedy Ratio ===
 Prvou z metód, ktorými potrebujeme našu triedu doplniť, je metóda, pomocou ktorej si môžeme naše objekty zobrazit (vytlačiť) v tvare zlomku

← Staršia verzia	Verzia zo dňa a času 15:24, 5. september 2010
(Žiaden rozdiel)

@@ Riadok 88: / Riadok 88: @@
 System.out.println("a= " + a);
 </source>
-Druhým problémom našej triedy je, že po každej matematickej operácii nám narastá numerická hodnota čitateľa aj menovateľa a teoreticky sa môžeme po nejakej dobe dostať k limitným hodnotám pre dátový typ určujúci ich numerický rozsah. Zmena dátového typu na väčší tento problém neodstráni, len potenciálne oddiali. Riešením je po každej numerickej operácii predeliť čitateľa aj menovateľa najväčším spoločným deliteľom a tým uržiavať čitateľa aj menovateľa na minimálnej možnej numerickej hodnote.
+Druhým problémom našej triedy je, že po každej matematickej operácii nám narastá numerická hodnota čitateľa aj menovateľa a teoreticky sa môžeme po nejakej dobe dostať k limitným hodnotám pre dátový typ určujúci ich numerický rozsah. Zmena dátového typu na väčší tento problém neodstráni, len potenciálne oddiali. Riešením je po každej numerickej operácii predeliť čitateľa aj menovateľa najväčším spoločným deliteľom a tým uržiavať čitateľa aj menovateľa na minimálnej možnej numerickej hodnote. K tomu nám poslúži metóda ''nsd'', ktorá zároveň aj upraví čitateľa a menovateľa. Pretože je zrejmé, že takéto úpravy môže robiť len objekt triedy v rámci vlastných 'kompetencií', '''nie je''' táto metóda deklarovaná ako ''public'', vyvolávajú ju ale interne metódy triedy.