Java 2
Operátory a základné príkazy
Cieľom
tohto textu a príslušných cvičení je oboznámiť sa s použitím
operátorov v Jave, s procesom logického vyhodnocovania, s príkazmi
cyklov a s jednoduchým použitím poľa.
Unárne operátory v Jave
Tieto operátory slúžia na
zvýšenie, zníženie hodnoty premennej o
jednotku. Ide o operátory ++ a --
Môžu sa použiť pred operandom, aj za operandom.
Podľa toho sú inkrementované, dekrementované (t.j. zväčšené, zmenšené) buď pred
použitím vo výraze, alebo po použití. Prezrite si nasledujúci kód a jeho
výstup – citované z knihz Bruce Eckela:
Kód P2.1
//:
c03:AutoInc.java
//
Demonstrates the ++ and -- operators.
public
class AutoInc {
public static void main(String[] args) {
int i = 1;
prt("i : " + i);
prt("++i : " + ++i); //
Pre-increment
prt("i++ : " + i++); //
Post-increment
prt("i : " + i);
prt("--i : " + --i); //
Pre-decrement
prt("i-- : " + i--); //
Post-decrement
prt("i : " + i);
}
static void prt(String s) {
System.out.println(s);
}
}
///:~
/*The output for this program is: [ Add Comment ]
i
: 1
++i
: 2
i++
: 2
i
: 3
--i
: 2
i--
: 2
i
: 1
*/
Binárne operátory v Jave
+ sčítanie
- odčítanie
* násobenie
/ reálne delenie
/ celočíselné delenie
% delenie modulo (t. j. zvyšok
po celočíselnom delení)
Pri aritmetických operáciách môže prísť k pretečeniu alebo podtečeniu,
pričom Java chybu nehlási. Pri týchto operáciách prichádza automaticky ku
konverzii primitívnych dátových typov. Napríklad:
Napríklad process
int i = 10;
float f = 99;
double d = f*i;
System.out.println(d);
Má tento výstup:
990.0
Samozrejme, niektoré operácie, na ktoré treba iba konkrétne dátové
typy, prekladač pri výskyte iných typov
vyhlási za chybné a kód nepreloží. Napríklad zápis
int i = 10;
float f = 99;
i = f%i;
má pri preklade za následok hlásenie:
possible loss of precision
found : float
required: int
Príklady skracovania zápisu pri binárnych operátoroch:
i = i+j;
skrátene i+=j;
i = i%j; skrátene i%=j;
booleanPrvy = booleanPrvy |
booleanDruhy; skrátene booleanPrvy |= booleanDruhy;
Relačné operátory
Tieto
operátory slúžia na vytvorenie booleovských výrazov, používaných pri
rozhodovaní o ďalšom priebehu programu. Napríklad v príkazoch typu if,
while atď.
Tu je zoznam používaných relačných operátorov:
== rovnosť
!= nerovnosť
&& logický súčin so skráteným vyhodnocovaním
|| logický súčet so
skráteným vyhodnocovaním
&
logický
súčin s úplným vyzhodnocovaním
| logický súčet s
úplným vyhodnocovaním
! negácia
<
menšie
<= menšie alebo rovné
> väčšie
>= väčšie alebo rovné
Pozor! Bežnou chybou je miesto „if(j==5)” napísať „if(j=5)”. V druhom prípade samozrejme v zátvorke nie je booleovský výraz, ale príkaz na
priradenie hodnoty 5 premennej j.
Preštudujte nasledujúci kód.
Povedzte, aký je rozdiel v logickom vyhodnocovaní výrazu pri označení
"alebo" symbolom
"|" a symbolom
"||" .
public
class SkrateneVyhodnocovanie{
public static void main(String[]
args){
// nastavim logicke premenne
na "nespravne" hodnoty
boolean jeVacsiRovnyAkoSto =
false;
boolean jeMensiRovnyAkoSto =
false;
int sto = 100;
System.out.println("\n Spustam prve vyhodnocovanie. ");
if(
(jeVacsiRovnyAkoSto=(sto>=100)) | (jeMensiRovnyAkoSto=(sto<=100))
) {
System.out.println("jeVacsiRovnyAkoSto
= " + jeVacsiRovnyAkoSto);
System.out.println("jeMensiRovnyAkoSto
= " + jeMensiRovnyAkoSto);
}//endOfIf
// znovu logicke hodnoty nastavim na
false
jeVacsiRovnyAkoSto = false;
jeMensiRovnyAkoSto = false;
System.out.println("\n Spustam druhe vyhodnocovanie.
");
if(
(jeVacsiRovnyAkoSto=(sto>=100)) || (jeMensiRovnyAkoSto=(sto<=100))
) {
System.out.println("jeVacsiRovnyAkoSto
= " + jeVacsiRovnyAkoSto);
System.out.println("jeMensiRovnyAkoSto
= " + jeMensiRovnyAkoSto);
}//endOfIf
}// endOfMain
}//endOfClass
Príklad použitia:
public class
BitoveOperacie {
public static void main(String[] args) {
char acko = 'a';
System.out.println("acko = " +
acko);
// nastavim siesty bit na nulu, t. j.
odratam hodnotu 32
acko =(char) ( (int)acko & 65503);
//
samozrejme, ide to aj jednoduchsie:
//acko = (char)(acko -32);
System.out.println("acko = " + acko);
// operacie OR a XOR
int i, k;
i = 129;
k = 255;
System.out.println("i
OR k = " + (i|k));
System.out.println("i
XOR k = " + (i^k));
}//endOfMain
}//endOfClass
Výpis z programu bude:
acko = a
acko = A
i OR k = 255
i XOR k =
126
Nasledujúce kódy ukazujú
najbežnejšie použitie príkazov cyklu: for , while a
do .... while
public class Cykly {
public
static void main(String[] args) {
for(int
i=1; i<=10; i++) {
System.out.println("Cyklus
for. Krok : " + i + ".");
}
int
j =121;
int
k =0;
int
stvorec = k*k;
while(stvorec
<= j) {
k++;
// znamena to iste, ako k = k+1;
stvorec
=k*k;
System.out.println("Cyklus
while. Stvorec = " + stvorec);
}
j
= 121;
k
= 0;
do{
k++;
// znamena to iste, ako k = k+1;
stvorec
=k*k;
System.out.println("Cyklus
do... while. Stvorec = " + stvorec);
}
while(
stvorec <= j);
j
=121;
k
=12;
stvorec
= k*k;
while(stvorec
<= j) {
k++;
// znamena to iste, ako k = k+1;
stvorec
=k*k;
System.out.println("Cyklus
while. Stvorec = " + stvorec);
}
j = 121;
k
= 12;
do{
k++;
// znamena to iste, ako k = k+1;
stvorec
=k*k;
System.out.println("Cyklus
do while. Stvorec = " + stvorec);
}
while(
stvorec <= j);
}//main
}// class
//
Vystup po zbehnuti programu:
/*
Cyklus
for. Krok : 1.
Cyklus for. Krok : 2.
Cyklus for. Krok : 3.
Cyklus for. Krok : 4.
Cyklus for. Krok : 5.
Cyklus for. Krok : 6.
Cyklus for. Krok : 7.
Cyklus for. Krok : 8.
Cyklus for. Krok : 9.
Cyklus for. Krok : 10.
Cyklus while. Stvorec = 1
Cyklus while. Stvorec = 4
Cyklus while. Stvorec = 9
Cyklus while. Stvorec = 16
Cyklus while. Stvorec = 25
Cyklus while. Stvorec = 36
Cyklus while. Stvorec = 49
Cyklus while. Stvorec = 64
Cyklus while. Stvorec = 81
Cyklus while. Stvorec = 100
Cyklus while. Stvorec = 121
Cyklus while. Stvorec = 144
Cyklus do... while. Stvorec = 1
Cyklus do... while. Stvorec = 4
Cyklus do... while. Stvorec = 9
Cyklus do... while. Stvorec = 16
Cyklus do... while. Stvorec = 25
Cyklus do... while. Stvorec = 36
Cyklus do... while. Stvorec = 49
Cyklus do... while. Stvorec = 64
Cyklus do... while. Stvorec = 81
Cyklus do... while. Stvorec = 100
Cyklus do... while. Stvorec = 121
Cyklus do... while. Stvorec = 144
Cyklus do while. Stvorec = 169
*/
public class Cycles {
public
static void main(String[] args) {
boolean jeToSranda = true;
for(int
i=1; i<=10; i++, jeToSranda = !jeToSranda) {
if(jeToSranda){
System.out.print(":-)
");
}
else
{
System.out.println(":-( ");
}
}//endOfFor
System.out.println(" Koniec cyklu \"for\"
");
boolean
jeToSmiesne = false;
System.out.println("Je
to smiesne = " + jeToSmiesne);
System.out.println("Som
pred cyklom \"while\"");
while(jeToSmiesne)
{
System.out.println("
chi chi chi");
}
System.out.println("Som pred cyklom
\"do ... while\"");
do{
System.out.println("
cho cho cho");
}
while(jeToSmiesne);
}//main
}// class
//
Vystup po zbehnuti:
/*
:-)
:-(
:-) :-(
:-) :-(
:-) :-(
:-) :-(
Koniec cyklu "for"
Je to smiesne = false
Som pred cyklom "while"
Som pred cyklom "do ... while"
cho cho cho
*/
Nasledujúci kód ukazuje, ako je možné použiť príkazy
continue a break . Continue preruší beh konkrétneho
kroku cyklu a začne sa ďalší krok. Break spôsobí úplné vyskočenie
z cyklu.
public class Veritel {
public
static void prt(String s){
System.out.println(s);
}
public
static void main(String[] args){
for(int
i = 200; i < 100000; i += 200) {
if(i > 1000) {
prt("Nic
ti nepoziciam. Najprv vrat, co mi dlzis!");
break;
}
prt("Pozical som ti " + i +"
korun.");
if(i > 600) {
continue;
}
prt("Priatelovi v nudzi rad
poziciam.");
}//endOfFor
}
}
Výstup programu je:
Pozical som ti 200 korun.
Priatelovi v nudzi rad poziciam.
Pozical som ti 400 korun.
Priatelovi v nudzi rad poziciam.
Pozical som ti 600 korun.
Priatelovi v nudzi rad poziciam.
Pozical som ti 800 korun.
Pozical som ti 1000 korun.
Nic ti nepoziciam. Najprv vrat, co mi dlzis!
public class
PoliaUvod {
public static void main(String[] args){
int[] vektor1, vektor2;
vektor1 = new int[3];
for(int i = 0; i < 3; i++){
vektor1[i] = i*2;
}
vektor2 = new int[]{2,0,-1};
int
skalarnySucin = 0;
for(int j = 0; j < 3; j++){
skalarnySucin += vektor1[j]*vektor2[j];
}
System.out.println("Skalarny
sucin sa rovna " + skalarnySucin);
double[][] matica = new double[3][3];
matica[0][2] = 1000;
System.out.println("matica[0][2] = " + matica[0][2] +
" matica[2][0] =
"+matica[2][0]);
}//endOfMain
Cv2. 1 Detektív Oriešok
Skúste uhádnuť, aký bude výstup z nasledujúceho programu. Program preložte a spustite:
public class
HlavolamP2 {
public static void main(String[] args){
int vyslednaSuma1 = 0;
int vyslednaSuma2 = 0;
for(int i =1, j=2; i<3; ){
vyslednaSuma1
+= (i++) + (j--);
}//endOfFor
for(int i =1, j=2;
i<3;){
vyslednaSuma2 += (i++) +(-- j);
}//endOfFor
System.out.println("Vysledna suma 1
je: " + vyslednaSuma1);
System.out.println("Vysledna suma 2 je: " + vyslednaSuma2);
}//endOfMain
}//endOfClass
Inšpirujte sa príkladom „Kód P2.6“. Vytvorte čo najpodobnejší cyklus, ktorý vypíše nasledujúci dialóg:
Oci,kup mi zmrzlinu.
Kupil som ti
1x zmrzlinu.
Chces este jednu?
Oci,kup mi
zmrzlinu.
Kupil som ti
2x zmrzlinu.
Chces este jednu?
Oci,kup mi
zmrzlinu.
Kupil som ti
3x zmrzlinu.
Oci,kup mi
zmrzlinu.
Kupil som ti
4x zmrzlinu.
Oci,kup mi
zmrzlinu.
Nic ti nekupim.Bude ta boliet brucho!
Vytvorte
program na násobenie matíc s celočíselnými hodnotami. Matice budú
reprezentované celočíselnými poľami.
END
© Ivan Kupka
© Ivan Kupka
Vaše komentáre:
kupka@fmph.uniba.sk