1 / 50

Using Java Operators

Using Java Operators. The Basic Toolkit Pliers, Screwdriver, Hammer and Drill. Assignment Operator ( = ). w = 10; x = w; z = (x - 2)/(2 + 2);. lvalue = rvalue;. Take the value of the rvalue and store it in the lvalue . The rvalue is any constant, variable or expression.

lavina
Télécharger la présentation

Using Java 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. Using Java Operators The Basic Toolkit Pliers, Screwdriver, Hammer and Drill

  2. Assignment Operator (=) w = 10; x = w; z = (x - 2)/(2 + 2); lvalue = rvalue; • Take the value of the rvalue and store it in the lvalue. • The rvalue is any constant, variable or expression. • The lvalue is named variable.

  3. Mathematical Operators • Addition + • Subtraction - • Multiplication * • Division / • Modulus %

  4. Simple Arithmetic public class Example { public static void main(String[] args) { int j, k, p, q, r, s, t; j = 5; k = 2; p = j + k; q = j - k; r = j * k; s = j / k; t = j % k; 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 = 7 q = 3 r = 10 s = 2 t = 1 >

  5. Shorthand Operators+=, -=, *=, /=, %= Common Shorthand a = a + b; a += b; a = a - b; a -= b; a = a * b; a *= b; a = a / b; a /= b; a = a % b; a %= b;

  6. Shorthand Operators 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 >

  7. Shorthand Increment and Decrement ++ and -- Common Shorthand a = a + 1; a++; or ++a; a = a - 1; a--; or --a;

  8. 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 >

  9. int 32 bit long 64 bit l i Casting A Change of Topic Arithmetic Operators

  10. Narrowing int 32 bit int 32 bit long 64 bit long 64 bit l l i i Moving Between Buckets"Casting" i = (int)l; l = (long)i; l = i; Widening long l; int i;

  11. The Primitive Numbers Declaration Size and Type Number Range byte b; // 8 bit integer -2-7 to +2+7-1 short s; // 16 bit integer -2-15 to +2+15-1 char c; // 16 bit Unicode 0 to +2+16 int i; // 32 bit integer -2-31 to +2+31-1 long l; // 64 bit integer -2-63 to +2+63-1 float f; // 32 bit floating point IEEE754 Standard double d; // 64 bit floating point IEEE754 Standard

  12. c = (char)b; c = (char)s; c = (char)i; c = (char)l; c = (char)f; c = (char)d; c = (char)b; c = (char)s; c = (char)i; c = (char)l; c = (char)f; c = (char)d; Positive Only Positive Only b = (byte)s; b = (byte)c; b = (byte)i; b = (byte)l; b = (byte)f; b = (byte)d; b = (byte)s; b = (byte)c; b = (byte)i; b = (byte)l; b = (byte)f; b = (byte)d; s = (short)b; s = (short)c; s = (short)i; s = (short)l; s = (short)f; s = (short)d; s = b; s = (short)c; s = (short)i; s = (short)l; s = (short)f; s = (short)d; i = (int)b; i = (int)s; i = (int)c; i = (int)l; i = (int)f; i = (int)d; i = b; i = s; i = c; i = (int)l; i = (int)f; i = (int)d; l = b; l = s; l = c; l = i; l = (long)f; l = (long)d; l = (long)b; l = (long)s; l = (long)c; l = (long)i; l = (long)f; l = (long)d; 2's Complement 2's Complement f = b; f = s; f = c; f = i; f = l; f = (float)d; f = (float)b; f = (float)s; f = (float)c; f = (float)i; f = (float)l; f = (float)d; d = (double)b; d = (double)s; d = (double)c; d = (double)i; d = (double)l; d = (double)f; d = b; d = s; d = c; d = i; d = l; d = f; Floating Point Floating Point Casting the Primitives

  13. char 16 bit byte 8 bit short 16 bit int 32 bit long 64 bit float 32 bit double 64 bit Acceptable Implicit Casts Illegal b = l; l = f; c = s; OK l = b; i = c; f = l

  14. char 16 bit char 16 bit byte 8 bit short 16 bit byte 8 bit short 16 bit int 32 bit int 32 bit long 64 bit long 64 bit float 32 bit float 32 bit double 64 bit double 64 bit Automatic Promotion with Arithmetic Arithmetic is never done in 8 or 16 bit containers. Illegal Casts s = s + b; s = s + s; OK s = (short)(s + b); s = (short)(s + s);

  15. char 16 bit byte 8 bit short 16 bit int 32 bit long 64 bit float 32 bit double 64 bit Arithmetic Promotion with Mixed Primitives Arithmetic is done in the "widest" type. Illegal Casts i = i + l; f = f + d; l = l + f; OK i = (int)(i + l); d = (double)(f + d); l = (long)(l + f);

  16. char 16 bit byte 8 bit short 16 bit int 32 bit long 64 bit float 32 bit double 64 bit Implicit Casts in Method Calls For: String st; and, public int indexOf(int ch); Illegal i = st.indexOf(f); OK i = st.indexOf(c); i = st.indexOf(b);

  17. A Change of Topic Casting The Logical and Relational Operators

  18. Relational Operators> < >= <= == != Primitives • Greater Than > • Less Than < • Greater Than or Equal >= • Less Than or Equal <= Primitives or Object References • Equal (Equivalent) == • Not Equal != The Result is Always true or false

  19. 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 >

  20. Logical Operators (boolean)&& || ! • Logical AND && • Logical OR || • Logical NOT !

  21. 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 >

  22. 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 >

  23. 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 >

  24. 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 >

  25. 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 >

  26. A Change of Topic The Logical and Relational Operators Manipulating the Bits 10010111

  27. Logical Operators (Bit Level)& | ^ ~ • AND & • OR | • XOR ^ • NOT ~

  28. 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

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

  30. 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

  31. 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 >

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

  33. 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

  34. 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

  35. 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 >

  36. 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

  37. Floating Point Integral Logical Any Object double float long int short char byte boolean Automatic Promotion Except ++ - - Automatic Promotion Except ++ - - Automatic Promotion Except ++ - - Automatic Promotion Except ++ - - Automatic Promotion Except ++ - - Automatic Promotion Except ++ - - + with String Only Reference Only Not Content Automatic Promotion Automatic Promotion Automatic Promotion Which Operators Operate On What Operators Unary + - ++ -- + - * / % > < >= <= == != = op= etc. << >> >>> & | ^ ~ && || !

  38. Assignment Operator (=) and Classes Date x = new Date(); Date y = new Date(); x = y;

  39. Assignment Operator (=) and Classes Date x = new Date(); Date y = new Date(); x = y;

  40. A Change of Topic Manipulating the Bits Some Odds and Ends

  41. Ternary Operator? : Any expression that evaluates to a boolean value. boolean_expression?expression_1:expression_2 If true this expression is evaluated and becomes the value entire expression. If false this expression is evaluated and becomes the value entire expression.

  42. Ternary ( ? : ) Operator Examples public class Example { public static void main(String[] args) { boolean t = true; boolean f = false; System.out.println("t?true:false "+(t ? true : false )); System.out.println("t?1:2 "+(t ? 1 : 2 )); System.out.println("f?true:false "+(f ? true : false )); System.out.println("f?1:2 "+(f ? 1 : 2 )); } } > java Example t?true:false true t?1:2 1 f?true:false false f?1:2 2 >

  43. String (+) OperatorString Concatenation "Now is " + "the time." "Now is the time."

  44. String (+) OperatorAutomatic Conversion to a String expression_1+expression_2 If either expression_1 If either expression_1 or expression_2 evaluates to a string the other will be converted to a string if needed. The result will be their concatenation.

  45. String (+) OperatorAutomatic Conversion with Primitives "The number is " + 4 "The number is " + "4" "The number is 4"

  46. String (+) OperatorAutomaticConversion with Objects "Today is " + new Date() "Today is " + new Date().toString() "Today is " + "Wed 27 22:12;26 CST 2000" "Today is Wed 27 22:12;26 CST 2000"

  47. Operator Precedence Unary Arithmetic Shift Comparison Logical Bit Boolean Ternary Assignment + - ++ -- ! ~ () * / % + - << >> >>> > < >= <= instanceof == != & | ^ && || ?: = (and += etc.)

  48. Passing Classes to Methods class Letter { char c; } public class PassObject { static void f(Letter y) { y.c = 'z'; } public static void main(String[] args) { Letter x = new Letter(); x.c = 'a'; System.out.println("1: x.c: " + x.c); // Prints 1: x.c: a f(x); System.out.println("2: x.c: " + x.c); // Prints 2: x.c: z } }

  49. Passing Primitives to Methods class Letter { char c; } public class PassPrimitive { static void f(char y) { y = 'z'; } public static void main(String[] args) { Letter x = new Letter(); x.c = 'a'; System.out.println("1: x.c: " + x.c); // Prints 1: x.c: a f(x.c); System.out.println("2: x.c: " + x.c); // Prints 2: x.c: a } }

  50. End of Content

More Related