1 / 35

Logical Operators

Logical Operators. Shorthand Operator. public class Example { public static void main(String[] args) { int j, p, q, r, s, t; j = 5; p = 1; q = 2; r = 3; s = 4; t = 5; p += j; q -= j; r *= j; s /= j; t %= j; System.out.println("p = " + p);

perry-pena
Download Presentation

Logical Operators

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Logical Operators

  2. Shorthand Operator public class Example { public static void main(String[] args) { int j, p, q, r, s, t; j = 5; p = 1; q = 2; r = 3; s = 4; t = 5; p += j; q -= j; r *= j; s /= j; t %= j; System.out.println("p = " + p); System.out.println("q = " + q); System.out.println("r = " + r); System.out.println("s = " + s); System.out.println("t = " + t); } } > java Example p = 6 q = -3 r = 15 s = 0 t = 0 >

  3. Increment/ Decrement Operators • Two unary operators: 1) ++ increments its operand by 1 2) -- decrements its operand by 1 • The operand must be a numerical variable. • Each operation can appear in two versions: • prefix version evaluates the value of the operand after performing the increment/decrement operation • postfix version evaluates the value of the operand before performing the increment/decrement operation

  4. Increment/ Decrement

  5. Increment and Decrement public class Example { public static void main(String[] args) { int j, p, q, r, s; j = 5; p = ++j; // j = j + 1; p = j; System.out.println("p = " + p); q = j++; // q = j; j = j + 1; System.out.println("q = " + q); System.out.println("j = " + j); r = --j; // j = j -1; r = j; System.out.println("r = " + r); s = j--; // s = j; j = j - 1; System.out.println("s = " + s); } } > java example p = 6 q = 6 j = 7 r = 6 s = 6 >

  6. Relational Operator • Relational operators determine the relationship that one operand has to the other operand, specifically equality and ordering. • The outcome is always a value of type boolean. • They are most often used in branching and loop control statements.

  7. Relational Operators

  8. Relational Operator Examples public class Example { public static void main(String[] args) { int p =2; int q = 2; int r = 3; Integer i = new Integer(10); Integer j = new Integer(10); System.out.println("p < r " + (p < r)); System.out.println("p > r " + (p > r)); System.out.println("p == q " + (p == q)); System.out.println("p != q " + (p != q)); System.out.println("i == j " + (i == j)); System.out.println("i != j " + (i != j)); } } > java Example p < r true p > r false p == q true p != q false i == j false i != j true >

  9. Logical Operators • Logical operators act upon boolean operands only. • The outcome is always a value of type boolean. • In particular, 1and2 and 1or2 logical operators occur in two forms: 1) full op1 & op2 and op1 | op2 where both op1 and op2 are evaluated 2) short-circuit - op1 && op2 and op1 || op2 where op2 is only evaluated if the value of op1 is insufficient to determine the final outcome

  10. Logical (&&) Operator Examples public class Example { public static void main(String[] args) { boolean t = true; boolean f = false; System.out.println("f && f " + (f && f)); System.out.println("f && t " + (f && t)); System.out.println("t && f " + (t && f)); System.out.println("t && t " + (t && t)); } } > java Example f && f false f && t false t && f false t && t true >

  11. Logical (||) Operator Examples public class Example { public static void main(String[] args) { boolean t = true; boolean f = false; System.out.println("f || f " + (f || f)); System.out.println("f || t " + (f || t)); System.out.println("t || f " + (t || f)); System.out.println("t || t " + (t || t)); } } > java Example f || f false f || t true t || f true t || t true >

  12. Logical (!) Operator Examples public class Example { public static void main(String[] args) { boolean t = true; boolean f = false; System.out.println("!f " + !f); System.out.println("!t " + !t); } } > java Example !f true !t false >

  13. Logical Operator ExamplesShort Circuiting with && public class Example { public static void main(String[] args) { boolean b; int j, k; j = 0; k = 0; b = ( j++ == k ) && ( j == ++k ); System.out.println("b, j, k " + b + ", " + j + ", " + k); j = 0; k = 0; b = ( j++ != k ) && ( j == ++k ); System.out.println("b, j, k " + b + ", " + j + ", " + k); } } > java Example b, j, k true 1, 1 > java Example b, j, k true 1, 1 b, j, k false 1, 0 >

  14. Logical Operator ExamplesShort Circuiting with || public class Example { public static void main(String[] args) { boolean b; int j, k; j = 0; k = 0; b = ( j++ == k ) || ( j == ++k ); System.out.println("b, j, k " + b + ", " + j + ", " + k); j = 0; k = 0; b = ( j++ != k ) || ( j == ++k ); System.out.println("b, j, k " + b + ", " + j + ", " + k); } } > java Example b, j, k true 1, 0 > java Example b, j, k true 1, 0 b, j, k true 1, 1 >

  15. Class Participation

  16. Answer

  17. Bitwise Operators • Bitwise operators apply to integer types only. • They act on individual bits of their operands. • There are three kinds of bitwise operators: 1) basic bitwise AND, OR, NOT and XOR 2) shifts left, right and right-zero-fill 3) assignments bitwise assignment for all basic and shift operators

  18. Bitwise Operators

  19. Twos Complement Numbers Base 10 A byte of binary +127 01111111 +4 00000100 +3 00000011 +2 00000010 +1 00000001 +0 00000000 -1 11111111 -2 11111110 -3 11111101 -4 11111100 -128 10000000

  20. Adding Twos Complements Base 10Binary +3 00000011 -2 11111110 +1 00000001 Base 10Binary +2 00000010 -3 11111101 -1 11111111

  21. Logical Operators (Bit Level)& | ^ ~ int a = 10; // 00001010 = 10 int b = 12; // 00001100 = 12 a 00000000000000000000000000001010 10 b 00000000000000000000000000001100 12 a & b 00000000000000000000000000001000 8 & AND a 00000000000000000000000000001010 10 b 00000000000000000000000000001100 12 a | b 00000000000000000000000000001110 14 | OR a 00000000000000000000000000001010 10 b 00000000000000000000000000001100 12 a ^ b 00000000000000000000000000000110 6 ^ XOR ~ NOT a 00000000000000000000000000001010 10 ~a 11111111111111111111111111110101 -11

  22. Logical (bit) Operator Examples public class Example { public static void main(String[] args) { int a = 10; // 00001010 = 10 int b = 12; // 00001100 = 12 int and, or, xor, na; and = a & b; // 00001000 = 8 or = a | b; // 00001110 = 14 xor = a ^ b; // 00000110 = 6 na = ~a; // 11110101 = -11 System.out.println("and " + and); System.out.println("or " + or); System.out.println("xor " + xor); System.out.println("na " + na); } } > java Example and 8 or 14 xor 6 na -11 >

  23. Shift Operators (Bit Level)<< >> >>> • Shift Left << Fill with Zeros • Shift Right >> Based on Sign • Shift Right >>> Fill with Zeros

  24. Shift Operators << >> int a = 3; // ...00000011 = 3 int b = -4; // ...11111100 = -4 a 00000000000000000000000000000011 3 a << 2 00000000000000000000000000001100 12 b 11111111111111111111111111111100 -4 b << 2 11111111111111111111111111110000 -16 << Left a 00000000000000000000000000000011 3 a >> 2 00000000000000000000000000000000 0 b 11111111111111111111111111111100 -4 b >> 2 11111111111111111111111111111111 -1 >> Right

  25. Shift Operator >>> int a = 3; // ...00000011 = 3 int b = -4; // ...11111100 = -4 a 00000000000000000000000000000011 3 a >>> 2 00000000000000000000000000000000 0 b 11111111111111111111111111111100 -4 b >>> 2 00111111111111111111111111111111 +big >>> Right 0

  26. Shift Operator Examples public class Example { public static void main(String[] args) { int a = 3; // ...00000011 = 3 int b = -4; // ...11111100 = -4 System.out.println("a<<2 = " + (a<<2)); System.out.println("b<<2 = " + (b<<2)); System.out.println("a>>2 = " + (a>>2)); System.out.println("b>>2 = " + (b>>2)); System.out.println("a>>>2 = " + (a>>>2)); System.out.println("b>>>2 = " + (b>>>2)); } } > java Example a<<2 = 12 b<<2 = -16 a>>2 = 0 b>>2 = -1 a>>>2 = 0 b>>>2 = 1073741823 >

  27. Shift Operator >>> and Automatic Arithmetic Promotion byte a = 3; // 00000011 = 3 byte b = -4; // 11111100 = -4 byte c; c = (byte) a >>> 2 c = (byte) b >>> 2 a 00000011 3 a >>> 2 00000000000000000000000000000000 0 c = (byte) 00000000 0 b 11111100 -4 b >>> 2 00111111111111111111111111111111 1073741823 c = (byte) Much to big for byte 11111111 -1 >>> Right Fill 0

  28. Other Operators

  29. Conditional Operators • General form: expr1? expr2 : expr3 where: 1) expr1 is of type boolean 2) expr2 and expr3 are of the same type If expr1 is true, expr2 is evaluated, otherwise expr3 is evaluated.

  30. Example: Conditional Operator

  31. Operator Precedence • Java operators are assigned precedence order. • Precedence determines that the expression 1 + 2 * 6 / 3 > 4 && 1 < 0 • if equivalent to (((1 + ((2 * 6) / 3)) > 4) && (1 < 0)) • When operators have the same precedence, the earlier one binds stronger.

  32. Operator Precedence

  33. Class Participation 1) What would be the result of running the following program: Class test {public static void main(String abc[]) { byte x=256; System.out.println(x); } } a) 256 b) Compilation Error c) Run Time Error

  34. Class Participation • Given a byte value of 01110111, which of the following statements will produce 00111011? (Note: 01110111= 0x77) A. 0x77<<1; B. 0x77>>>1; C. 0x77>>1; D. B and C E. None of the above

  35. Questions?

More Related