Transcript Logikai kifejezések fölírásának gyakorlása

Java
Feltételek, logikai
kifejezések
jt
Logikai operátorok
Logikai kifejezésekre alkalmazhatók a következő
műveletek:
1. nem
!
2. és
&
ill. &&
3. kizáró vagy
^
4. vagy
|
ill. ||
Az && ill. a || művelet az ún. rövid kiértékelésű
változatok. Ez azt jelenti, hogy csak addig történik
kiértékelés, amíg a pr. el nem tudja dönteni a
végeredményt.
jt
2
A következő pr. arra példa, hogy a rövid és a teljes
kiértékelés más végrehajtást eredményez(het):
import extra.Console;
public class MitCsinal303{
public static void main(String args[]){
boolean vanA;
vanA = Console.readChar("Kerek egy betut: ") == 'A' ||
Console.readChar("Meg egyet: ") == 'A';
System.out.println("Volt benne A betu: " + vanA);
System.out.println();
}
}
Futassuk a pr-ot úgy is, hogy a || jelet |-re cseréljük!
jt
3
Nagyon fontos tehát, hogy pl. ha az előző
műveletek rövid változatát (&&, ||) használjuk,
akkor olyan eset is elképzelhető, mikor egy
értékadás nem történik meg.
a && b || c
Ha a és b is igaz, tök mindegy, hogy mi a c.
Rövidzár esetén ugyanis a c nem is hajtódik végre.
Márpedig ha itt éppen egy értékadás szerepel, akkor
az meg sem történik!!! Ez pedig azért nem éppen
lényegtelen dolog.
Ez szintaktikai hibát nem okoz, de lehet, hogy a pr.
helytelenül fog működni. 
jt
4
Bitenkénti operátorok
A log-i műveletek bitekre is alkalmazhatók. A
bitenkénti ~ (nem), & (és), | (vagy), ^ (kizáró vagy)
műveletek bitenként végzik el a log-i
műveleteket úgy, hogy az 1 true, a 0 pedig false
értéknek számít. A műveletek mindig az
egymásnak megfeleltethető biteken hajtódnak
végre.
A << (shift-left) operátor 1-gyel balra tolja a biteket úgy, hogy
jobbról 0-k „jönnek be”.
A >> (shift-right) operátor 1-gyel jobbra tolja a biteket úgy, hogy
balról 1-esek „jönnek be”.
A >>> (shift-right-with-zero-fill) operátor 1-gyel jobbra tolja a biteket úgy, hogy balról 0-k „jönnek be”.
jt
5
Például:
import extra.Console;
public class BitMuveletek{
public static void main(String args[]){
int b=124;
// 01111100
System.out.println("~b: " + ~b);
System.out.println("b|1: " + (b|1));
System.out.println("b&4: " + (b&4));
System.out.println("b^2: " + (b^2));
System.out.println(b<<1);
System.out.println(b>>1);
// 10000011 = -125
// 01111101 = 125
// 00000100 = 4
// 01111110 = 126
// 11111000 = 248
// 00111110 = 62
System.out.println();
}
}
jt
6
Feltétel
Feltételnek nevezzük a boolean típusú kifejezést.
Pl.: a==b & a%2==0 | !(a+b<10)
Ezek eredménye true vagy false,
tehát az egész kifejezés értéke
vagy true vagy false lesz.
jt
7
A feltételek és különösen az összetett feltételek
megfogalmazása és felírása nem mindig
egyszerű feladat.
• Először meg kell fogalmazni az egyszerű
feltételeket.
• Ezután az egyszerű feltételeket összekapcsoljuk
logikai műveletekkel. A prioritási szabályokra
ügyelni kell!
–
–
–
–
Legerősebb a nem (!).
Második az és (&).
Harmadik a kizáró vagy (^).
Aztán a vagy (|).
–
–
&&
||
jt
8
• Ezek után megpróbáljuk a feltételt minél
egyszerűbb formára hozni.
• Végül a feltételt száraz teszt alá vetjük, vagyis
több konkrét esetre kipróbáljuk, hogy helyes-e az
eredmény.
Példák
Legyenek a, b, c és d int típusú változók!
1)
a értéke 0 és 1 közé esik (a határokat is beleértve) :
a>=0 & a<=1
jt
9
2) a és b közül egyik sem nulla:
•
•
•
•
a nem nulla:
a != 0
b nem nulla:
b != 0
Teljesüljön mindkét feltétel egyszerre!
a != 0 && b != 0
Tesztelés: Legyen pl. a=0 és b=3!
3) a 25-nél nagyobb és páros, b pedig (a határokat is beleértve)
1000 és 2000 közé eső, nullára végződő szám:
(a>25 && a%2==0) && (b>=1000 && b<=2000 && b%10==0)
jt
10
4) a és b közül legalább az egyik nagyobb, mint 10:
a>10 | b>10
5) a és b közül pontosan az egyik nagyobb, mint 10:
a>10 ^ b>10
(kizáró vagy, XOR)
6) a és b közül, valamint c és d közül legalább az
egyik nagyobb, mint 10:
(Itt a zárójel használata fontos, mert az és
(a>10 | b>10) & (c>10 | d>10)
művelet erősebb, mint a vagy.)
7) ,Vagy az a és b közül, vagy a c és d közül
mindkettő nagyobb, mint 10.
a>10 & b>10 | c>10 & d>10
jt
(Itt nem kell zárójelet használni.)
11