Presentation is loading. Please wait.

Presentation is loading. Please wait.

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

Published byTheodora Lester Modified over 8 years ago

Similar presentations

Presentation on theme: "© 2001 by Ashby M. Woolf Revision 3 Using Java Operators The Basic Toolkit Pliers, Screwdriver, Hammer and Drill."— Presentation transcript:

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

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

3 © 2001 by Ashby M. Woolf Revision 3 Mathematical Operators Addition + Subtraction - Multiplication * Division/ Modulus%

4 © 2001 by Ashby M. Woolf Revision 3 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 © 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;

6 © 2001 by Ashby M. Woolf Revision 3 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 © 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;

8 © 2001 by Ashby M. Woolf Revision 3 Increment and Decrement > java example p = 6 q = 6 j = 7 r = 6 s = 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); }

9 © 2001 by Ashby M. Woolf Revision 3 Arithmetic Operators A Change of Topic Casting long 64 bit l int 32 bit i

10 © 2001 by Ashby M. Woolf Revision 3 long 64 bit int 32 bit l i int i; i = (int)l; l = (long)i; Moving Between Buckets "Casting" long l; l = i; long 64 bit int 32 bit l i Widening Narrowing

11 © 2001 by Ashby M. Woolf Revision 3 DeclarationSize and TypeNumber 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 pointIEEE754 Standard double d;// 64 bit floating pointIEEE754 Standard The Primitive Numbers

12 © 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 Complement c = (char)b; c = (char)s; c = (char)i; c = (char)l; c = (char)f; c = (char)d; Positive Only 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; Floating Point 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 Complement c = (char)b; c = (char)s; c = (char)i; c = (char)l; c = (char)f; c = (char)d; Positive Only 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; Floating Point

13 © 2001 by Ashby M. Woolf Revision 3 Acceptable Implicit Casts char 16 bit double 64 bit float 32 bit long 64 bit int 32 bit short 16 bit byte 8 bit Illegal b = l; l = f; c = s; OK l = b; i = c; f = l

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

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

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

17 © 2001 by Ashby M. Woolf Revision 3 Casting A Change of Topic The Logical and Relational Operators

18 © 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

19 © 2001 by Ashby M. Woolf Revision 3 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 © 2001 by Ashby M. Woolf Revision 3 Logical Operators (boolean) && || ! Logical AND && Logical OR || Logical NOT !

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

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

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

24 © 2001 by Ashby M. Woolf Revision 3 Logical Operator Examples Short 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 © 2001 by Ashby M. Woolf Revision 3 Logical Operator Examples Short 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 © 2001 by Ashby M. Woolf Revision 3 The Logical and Relational Operators A Change of Topic Manipulating the Bits 10010111

27 © 2001 by Ashby M. Woolf Revision 3 Logical Operators (Bit Level) & | ^ ~ AND & OR | XOR ^ NOT ~

28 © 2001 by Ashby M. Woolf Revision 3 Twos Complement Numbers Base 10 A byte of binary +12701111111 +400000100 +300000011 +200000010 +100000001 +000000000 -111111111 -211111110 -311111101 -411111100 -12810000000

29 © 2001 by Ashby M. Woolf Revision 3 Adding Twos Complements Base 10Binary +300000011 -211111110 +100000001 Base 10Binary +200000010 -311111101 -111111111

30 © 2001 by Ashby M. Woolf Revision 3 Logical Operators (Bit Level) & | ^ ~ int a = 10; // 00001010 = 10 int b = 12; // 00001100 = 12 a00000000000000000000000000001010 10 b00000000000000000000000000001100 12 a & b00000000000000000000000000001000 8 a00000000000000000000000000001010 10 b00000000000000000000000000001100 12 a | b00000000000000000000000000001110 14 a00000000000000000000000000001010 10 b00000000000000000000000000001100 12 a ^ b00000000000000000000000000000110 6 a00000000000000000000000000001010 10 ~a11111111111111111111111111110101 -11 & AND | OR ^ XOR ~ NOT

31 © 2001 by Ashby M. Woolf Revision 3 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 © 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

33 © 2001 by Ashby M. Woolf Revision 3 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 >> Right a 00000000000000000000000000000011 3 a >> 2 00000000000000000000000000000000 0 b 11111111111111111111111111111100 -4 b >> 2 11111111111111111111111111111111 -1

34 © 2001 by Ashby M. Woolf Revision 3 Shift Operator >>> int a = 3; //...00000011 = 3 int b = -4; //...11111100 = -4 >>> Right 0 a 00000000000000000000000000000011 3 a >>> 2 00000000000000000000000000000000 0 b 11111111111111111111111111111100 -4 b >>> 2 00111111111111111111111111111111 +big

35 © 2001 by Ashby M. Woolf Revision 3 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 © 2001 by Ashby M. Woolf Revision 3 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 >>> Right Fill 0 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

37 © 2001 by Ashby M. Woolf Revision 3 Which Operators Operate On What Operators && || ! Unary + - ++ -- + - * / % > = <= == != > >>> & | ^ ~ = op= etc. floatdouble Floating Point charbyteshortintlong Automatic Promotion Except ++ - - Automatic Promotion Except ++ - - Automatic Promotion Except ++ - - Automatic Promotion Except ++ - - Automatic Promotion Except ++ - - Automatic Promotion Except ++ - - Automatic Promotion Automatic Promotion Automatic Promotion Integral boolean Logical Any Object + with String Only Reference Only Not Content

38 © 2001 by Ashby M. Woolf Revision 3 Assignment Operator (=) and Classes Date x = new Date(); Date y = new Date(); x = y;

39 © 2001 by Ashby M. Woolf Revision 3 Assignment Operator (=) and Classes Date x = new Date(); Date y = new Date(); x = y;

40 © 2001 by Ashby M. Woolf Revision 3 Manipulating the Bits A Change of Topic Some Odds and Ends

41 © 2001 by Ashby M. Woolf Revision 3 Ternary Operator ? : If true this expression is evaluated and becomes the value entire expression. Any expression that evaluates to a boolean value. If false this expression is evaluated and becomes the value entire expression. boolean_expression ? expression_1 : expression_2

42 © 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 >

43 © 2001 by Ashby M. Woolf Revision 3 String (+) Operator String Concatenation "Now is " + "the time." "Now is the time."

44 © 2001 by Ashby M. Woolf Revision 3 String (+) Operator Automatic Conversion to a String 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. expression_1 + expression_2

45 © 2001 by Ashby M. Woolf Revision 3 String (+) Operator Automatic Conversion with Primitives "The number is " + 4 "The number is " + "4" "The number is 4"

46 © 2001 by Ashby M. Woolf Revision 3 String (+) Operator Automatic 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()

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

48 © 2001 by Ashby M. Woolf Revision 3 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 © 2001 by Ashby M. Woolf Revision 3 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 © 2001 by Ashby M. Woolf Revision 3 End of Content

Download ppt "© 2001 by Ashby M. Woolf Revision 3 Using Java Operators The Basic Toolkit Pliers, Screwdriver, Hammer and Drill."

Similar presentations

Types, Variables and Operators Computer Engineering Department Java Course Asst. Prof. Dr. Ahmet Sayar Kocaeli University - Fall 2013.

Types, Variables and Operators Computer Engineering Department Java Course Asst. Prof. Dr. Ahmet Sayar Kocaeli University - Fall 2013.
Data Types in Java Data is the information that a program has to work with. Data is of different types. The type of a piece of data tells Java what can.

Data Types in Java Data is the information that a program has to work with. Data is of different types. The type of a piece of data tells Java what can.
IntroductionIntroduction  Computer program: an ordered sequence of statements whose objective is to accomplish a task.  Programming: process of planning.

IntroductionIntroduction  Computer program: an ordered sequence of statements whose objective is to accomplish a task.  Programming: process of planning.
1 Data types, operations, and expressions Overview l Primitive Data Types l Variable declaration l Arithmetical Operations l Expressions.

1 Data types, operations, and expressions Overview l Primitive Data Types l Variable declaration l Arithmetical Operations l Expressions.
Aalborg Media Lab 21-Jun-15 Software Design Lecture 2 “ Data and Expressions”

Aalborg Media Lab 21-Jun-15 Software Design Lecture 2 “ Data and Expressions”
Program Elements We can now examine the core elements of programming (as implemented in Java) We focuse on: data types variable declaration and use, constants.

Program Elements We can now examine the core elements of programming (as implemented in Java) We focuse on: data types variable declaration and use, constants.
The UNIVERSITY of NORTH CAROLINA at CHAPEL HILL Adrian Ilie COMP 14 Introduction to Programming Adrian Ilie June 27, 2005.

The UNIVERSITY of NORTH CAROLINA at CHAPEL HILL Adrian Ilie COMP 14 Introduction to Programming Adrian Ilie June 27, 2005.
Expressions An expression is a sequence of operands and operators that reduces to a single value. 5 + 2 expression operator operand An operator is a language-specific.

Expressions An expression is a sequence of operands and operators that reduces to a single value expression operator operand An operator is a language-specific.
Primitive Types Java supports two kinds of types of values – objects, and – values of primitive data types variables store – either references to objects.

Primitive Types Java supports two kinds of types of values – objects, and – values of primitive data types variables store – either references to objects.
Lecture 2: Topics Bits and Bytes Primitive Types Casting Strings Boolean expressions.

Lecture 2: Topics Bits and Bytes Primitive Types Casting Strings Boolean expressions.
2015/8/221 Data Types & Operators Lecture from (Chapter 3,4)

2015/8/221 Data Types & Operators Lecture from (Chapter 3,4)
1 Chapter Two Using Data. 2 Objectives Learn about variable types and how to declare variables Learn how to display variable values Learn about the integral.

1 Chapter Two Using Data. 2 Objectives Learn about variable types and how to declare variables Learn how to display variable values Learn about the integral.
Chapter 2: Introducing Data Types and Operators.  Know Java’s primitive types  Use literals  Initialize variables  Know the scope rules of variables.

Chapter 2: Introducing Data Types and Operators.  Know Java’s primitive types  Use literals  Initialize variables  Know the scope rules of variables.
 Value, Variable and Data Type  Type Conversion  Arithmetic Expression Evaluation  Scope of variable.

 Value, Variable and Data Type  Type Conversion  Arithmetic Expression Evaluation  Scope of variable.
Java Primitives The Smallest Building Blocks of the Language (corresponds with Chapter 2)

Java Primitives The Smallest Building Blocks of the Language (corresponds with Chapter 2)
Chapter 2: Basic Elements of Java J ava P rogramming: From Problem Analysis to Program Design, From Problem Analysis to Program Design, Second Edition.

Chapter 2: Basic Elements of Java J ava P rogramming: From Problem Analysis to Program Design, From Problem Analysis to Program Design, Second Edition.
Chapter 2 Basic Elements of Java. Chapter Objectives Become familiar with the basic components of a Java program, including methods, special symbols,

Chapter 2 Basic Elements of Java. Chapter Objectives Become familiar with the basic components of a Java program, including methods, special symbols,
Operators 2015-10-121. Using Java operators An operator takes one or more arguments and produces a new value. All operators produce a value from their.

Operators Using Java operators An operator takes one or more arguments and produces a new value. All operators produce a value from their.
Simple Data Types and Statements. Namespaces namespace MyNamespace { // …. { MyNamespace::func1() using namespace OtherNamespace; Comments: // /* xxxx.

Simple Data Types and Statements. Namespaces namespace MyNamespace { // …. { MyNamespace::func1() using namespace OtherNamespace; Comments: // /* xxxx.
Java Software Solutions Lewis and Loftus Chapter 5 1 Copyright 1997 by John Lewis and William Loftus. All rights reserved. More Programming Constructs.

Java Software Solutions Lewis and Loftus Chapter 5 1 Copyright 1997 by John Lewis and William Loftus. All rights reserved. More Programming Constructs.

Similar presentations

Ads by Google