© 2001 by Ashby M. Woolf Revision 3 Using Java Operators The Basic Toolkit Pliers, Screwdriver,...

© 2001 by Ashby M. Woolf Revision 3

Using Java Operators

The Basic Toolkit

Pliers, Screwdriver, Hammer and Drill


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);


Mathematical Operators

• Addition +• Subtraction -• Multiplication *• Division /• Modulus %


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 >


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;


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>


Shorthand Increment and Decrement ++ and --

Common Shorthand

a = a + 1; a++; or ++a;

a = a - 1; a--; or --a;


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);

}}


Arithmetic

Operators

A Change of Topic

Casting

long64 bit

l

int32 bit

i


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


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


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


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


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.


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.


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);


Casting

A Change of Topic

The Logicaland

Relational Operators


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


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 >


Logical Operators (boolean) && || !

• Logical AND &&

• Logical OR ||

• Logical NOT !


Logical (&&) Operator Examples


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 >


Logical (||) Operator Examples



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 >


Logical (!) Operator Examples



System.out.println("!f " + !f);System.out.println("!t " + !t);

}}

> java Example !f true !t false >


Logical Operator ExamplesShort Circuiting with &&


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 >


Logical Operator ExamplesShort Circuiting with ||


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 >


The Logical andRelational Operators

A Change of Topic

Manipulatingthe Bits 10010111


Logical Operators (Bit Level) & | ^ ~

• AND &• OR |• XOR ^• NOT ~


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


Adding Twos Complements

Base 10 Binary

+3 00000011

-2 11111110

+1 00000001

Base 10 Binary

+2 00000010

-3 11111101

-1 11111111


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


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 >


Shift Operators (Bit Level) << >> >>>

• Shift Left << Fill with Zeros

• Shift Right >> Based on Sign

• Shift Right >>> Fill with Zeros


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


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


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 >


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


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


Assignment Operator (=) and Classes

Date x = new Date();

Date y = new Date();

x = y;


Manipulatingthe Bits

A Change of Topic

Some Oddsand Ends


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


Ternary ( ? : ) Operator Examples



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 >


String (+) OperatorString Concatenation

"Now is " + "the time."

"Now is the time."


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


String (+) OperatorAutomatic Conversion with Primitives

"The number is " + 4

"The number is " + "4"

"The number is 4"


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()


Operator Precedence

+ - ++ -- ! ~ ()

* / %

+ -

<< >> >>>

> < >= <= instanceof

== !=

& | ^

&& ||

?:

= (and += etc.)

Unary

Arithmetic

Shift

Comparison

Logical Bit

Boolean

Ternary

Assignment


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 }}


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 }}


End of Content

© 2001 by Ashby M. Woolf Revision 3 Using Java Operators The Basic Toolkit Pliers, Screwdriver,...

Documents

Transcript of © 2001 by Ashby M. Woolf Revision 3 Using Java Operators The Basic Toolkit Pliers, Screwdriver,...