Post on 26-Dec-2015
transcript
© 2001 by Ashby M. Woolf Revision 3
Using Java Operators
The Basic Toolkit
Pliers, Screwdriver, Hammer and Drill
© 2001 by Ashby M. Woolf Revision 3
Assignment Operator (=)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.
w = 10;
x = w;
z = (x - 2)/(2 + 2);
© 2001 by Ashby M. Woolf Revision 3
Mathematical Operators
• Addition +• Subtraction -• Multiplication *• Division /• Modulus %
© 2001 by Ashby M. Woolf Revision 3
Simple Arithmeticpublic 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 >
© 2001 by Ashby M. Woolf Revision 3
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;
© 2001 by Ashby M. Woolf Revision 3
Shorthand Operatorspublic 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 = 6q = -3r = 15s = 0t = 0>
© 2001 by Ashby M. Woolf Revision 3
Shorthand Increment and Decrement ++ and --
Common Shorthand
a = a + 1; a++; or ++a;
a = a - 1; a--; or --a;
© 2001 by Ashby M. Woolf Revision 3
Increment and Decrement
> java examplep = 6q = 6j = 7r = 6s = 6>
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);
}}
© 2001 by Ashby M. Woolf Revision 3
Arithmetic
Operators
A Change of Topic
Casting
long64 bit
l
int32 bit
i
© 2001 by Ashby M. Woolf Revision 3
long64 bit
int32 bit
liint i;
i = (int)l;
l = (long)i;
Moving Between Buckets"Casting"
long l;
l = i;
long64 bit
int32 bit
li
Widening
Narrowing
© 2001 by Ashby M. Woolf Revision 3
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
The Primitive Numbers
© 2001 by Ashby M. Woolf Revision 3
Casting the Primitives
b = (byte)s;b = (byte)c;b = (byte)i;b = (byte)l;b = (byte)f;b = (byte)d;
i = (int)b;i = (int)s;i = (int)c;i = (int)l;i = (int)f;i = (int)d;
l = (long)b;l = (long)s;l = (long)c;l = (long)i;l = (long)f;l = (long)d;
s = (short)b;s = (short)c;s = (short)i;s = (short)l;s = (short)f;s = (short)d;
2's
Co
mp
lem
ent
c = (char)b;c = (char)s;c = (char)i;c = (char)l;c = (char)f;c = (char)d;P
osi
tive
On
ly
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;F
loat
ing
Po
int
b = (byte)s;b = (byte)c;b = (byte)i;b = (byte)l;b = (byte)f;b = (byte)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;
s = b;s = (short)c;s = (short)i;s = (short)l;s = (short)f;s = (short)d;2'
s C
om
ple
men
t
c = (char)b;c = (char)s;c = (char)i;c = (char)l;c = (char)f;c = (char)d;P
osi
tive
On
ly
f = b;f = s;f = c;f = i;f = l;f = (float)d;
d = b;d = s;d = c;d = i;d = l;d = f;F
loat
ing
Po
int
© 2001 by Ashby M. Woolf Revision 3
Acceptable Implicit Casts
char16 bit
double64 bit
float32 bit
long64 bit
int32 bit
short16 bit
byte8 bit
Illegal b = l;l = f;c = s;
OKl = b;i = c;f = l
© 2001 by Ashby M. Woolf Revision 3
char16 bit
double64 bit
float32 bit
long64 bit
int32 bit
short16 bit
byte8 bit
char16 bit
double64 bit
float32 bit
long64 bit
int32 bit
short16 bit
byte8 bit
Automatic Promotion with Arithmetic
Illegal Castss = s + b;s = s + s;
OKs = (short)(s + b);s = (short)(s + s);
Arithmetic is never donein 8 or 16 bit containers.
© 2001 by Ashby M. Woolf Revision 3
char16 bit
double64 bit
float32 bit
long64 bit
int32 bit
short16 bit
byte8 bit
Arithmetic Promotion with Mixed Primitives
Illegal Castsi = i + l;f = f + d;l = l + f;
OKi = (int)(i + l);d = (double)(f + d);l = (long)(l + f);
Arithmetic is donein the "widest" type.
© 2001 by Ashby M. Woolf Revision 3
Implicit Casts in Method Calls
char16 bit
double64 bit
float32 bit
long64 bit
int32 bit
short16 bit
byte8 bit
Illegal i = st.indexOf(f);
OKi = st.indexOf(c);i = st.indexOf(b);
For: String st; and,public int indexOf(int ch);
© 2001 by Ashby M. Woolf Revision 3
Casting
A Change of Topic
The Logicaland
Relational Operators
© 2001 by Ashby M. Woolf Revision 3
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
© 2001 by Ashby M. Woolf Revision 3
Relational Operator Examplespublic 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 >
© 2001 by Ashby M. Woolf Revision 3
Logical Operators (boolean) && || !
• Logical AND &&
• Logical OR ||
• Logical NOT !
© 2001 by Ashby M. Woolf Revision 3
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 >
© 2001 by Ashby M. Woolf Revision 3
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 >
© 2001 by Ashby M. Woolf Revision 3
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 >
© 2001 by Ashby M. Woolf Revision 3
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 >
© 2001 by Ashby M. Woolf Revision 3
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 >
© 2001 by Ashby M. Woolf Revision 3
The Logical andRelational Operators
A Change of Topic
Manipulatingthe Bits 10010111
© 2001 by Ashby M. Woolf Revision 3
Logical Operators (Bit Level) & | ^ ~
• AND &• OR |• XOR ^• NOT ~
© 2001 by Ashby M. Woolf Revision 3
Twos Complement NumbersBase 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
© 2001 by Ashby M. Woolf Revision 3
Adding Twos Complements
Base 10 Binary
+3 00000011
-2 11111110
+1 00000001
Base 10 Binary
+2 00000010
-3 11111101
-1 11111111
© 2001 by Ashby M. Woolf Revision 3
Logical Operators (Bit Level) & | ^ ~
int a = 10; // 00001010 = 10int b = 12; // 00001100 = 12
a 00000000000000000000000000001010 10b 00000000000000000000000000001100 12a & b 00000000000000000000000000001000 8
a 00000000000000000000000000001010 10b 00000000000000000000000000001100 12a | b 00000000000000000000000000001110 14
a 00000000000000000000000000001010 10b 00000000000000000000000000001100 12a ^ b 00000000000000000000000000000110 6
a 00000000000000000000000000001010 10~a 11111111111111111111111111110101 -11
&AND
|OR
^XOR
~NOT
© 2001 by Ashby M. Woolf Revision 3
Logical (bit) Operator Examplespublic class Example {
public static void main(String[] args) {int a = 10; // 00001010 = 10int b = 12; // 00001100 = 12int and, or, xor, na;and = a & b; // 00001000 = 8or = a | b; // 00001110 = 14xor = a ^ b; // 00000110 = 6na = ~a; // 11110101 = -11System.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 >
© 2001 by Ashby M. Woolf Revision 3
Shift Operators (Bit Level) << >> >>>
• Shift Left << Fill with Zeros
• Shift Right >> Based on Sign
• Shift Right >>> Fill with Zeros
© 2001 by Ashby M. Woolf Revision 3
Shift Operators << >>
int a = 3; // ...00000011 = 3int b = -4; // ...11111100 = -4
a 00000000000000000000000000000011 3a << 2 00000000000000000000000000001100 12
b 11111111111111111111111111111100 -4b << 2 11111111111111111111111111110000 -16
<<Left
>>Right
a 00000000000000000000000000000011 3a >> 2 00000000000000000000000000000000 0
b 11111111111111111111111111111100 -4b >> 2 11111111111111111111111111111111 -1
© 2001 by Ashby M. Woolf Revision 3
Shift Operator >>>
int a = 3; // ...00000011 = 3int b = -4; // ...11111100 = -4
>>>Right 0
a 00000000000000000000000000000011 3a >>> 2 00000000000000000000000000000000 0
b 11111111111111111111111111111100 -4b >>> 2 00111111111111111111111111111111 +big
© 2001 by Ashby M. Woolf Revision 3
Shift Operator Examplespublic class Example {
public static void main(String[] args) {int a = 3; // ...00000011 = 3int 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 >
© 2001 by Ashby M. Woolf Revision 3
Shift Operator >>> and Automatic Arithmetic Promotion
byte a = 3; // 00000011 = 3byte b = -4; // 11111100 = -4byte c;c = (byte) a >>> 2c = (byte) b >>> 2
>>>RightFill 0
a 00000011 3a >>> 2 00000000000000000000000000000000 0c = (byte) 00000000 0
b 11111100 -4b >>> 2 00111111111111111111111111111111 1073741823c = (byte) Much to big for byte 11111111 -1
© 2001 by Ashby M. Woolf Revision 3
Which Operators Operate On What
Operators
&& || !
Unary+ - ++ --
+ - * / %
> < >= <=
== !=
<< >> >>>& | ^ ~
=op= etc.
floatdouble
Floating Point
char byteshortintlongAutomaticPromotion
Except ++ - -
AutomaticPromotion
Except ++ - -
AutomaticPromotion
Except ++ - -
AutomaticPromotion
Except ++ - -
AutomaticPromotion
Except ++ - -
AutomaticPromotion
Except ++ - -
AutomaticPromotion
AutomaticPromotion
AutomaticPromotion
Integral
boolean
Logical AnyObject
+ withStringOnly
ReferenceOnly
Not Content
© 2001 by Ashby M. Woolf Revision 3
Assignment Operator (=) and Classes
Date x = new Date();
Date y = new Date();
x = y;
© 2001 by Ashby M. Woolf Revision 3
Assignment Operator (=) and Classes
Date x = new Date();
Date y = new Date();
x = y;
© 2001 by Ashby M. Woolf Revision 3
Manipulatingthe Bits
A Change of Topic
Some Oddsand Ends
© 2001 by Ashby M. Woolf Revision 3
Ternary Operator ? :
If true this expression is evaluated and becomes the value entire expression.
Any expression that evaluatesto a boolean value.
If false this expression is evaluated and becomes the value entire expression.
boolean_expression ? expression_1 : expression_2
© 2001 by Ashby M. Woolf Revision 3
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 >
© 2001 by Ashby M. Woolf Revision 3
String (+) OperatorString Concatenation
"Now is " + "the time."
"Now is the time."
© 2001 by Ashby M. Woolf Revision 3
String (+) OperatorAutomatic Conversion to a String
If either expression_1If either expression_1 or expression_2 evaluatesto a string the other will be converted to a string if needed. The result will be their concatenation.
expression_1 + expression_2
© 2001 by Ashby M. Woolf Revision 3
String (+) OperatorAutomatic Conversion with Primitives
"The number is " + 4
"The number is " + "4"
"The number is 4"
© 2001 by Ashby M. Woolf Revision 3
String (+) OperatorAutomatic Conversion with Objects
"Today is " + new Date()
"Today is " + "Wed 27 22:12;26 CST 2000"
"Today is Wed 27 22:12;26 CST 2000"
"Today is " + new Date().toString()
© 2001 by Ashby M. Woolf Revision 3
Operator Precedence
+ - ++ -- ! ~ ()
* / %
+ -
<< >> >>>
> < >= <= instanceof
== !=
& | ^
&& ||
?:
= (and += etc.)
Unary
Arithmetic
Shift
Comparison
Logical Bit
Boolean
Ternary
Assignment
© 2001 by Ashby M. Woolf Revision 3
Passing Classes to Methodsclass 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 }}
© 2001 by Ashby M. Woolf Revision 3
Passing Primitives to Methodsclass 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 }}
© 2001 by Ashby M. Woolf Revision 3
End of Content