Chapter 2: Java Fundamentals

1 / 49

# Chapter 2: Java Fundamentals - PowerPoint PPT Presentation

Chapter 2: Java Fundamentals. Operators. Content. Group of Operators Arithmetic Operators Assignment Operator Order of Precedence Increment/Decrement Operators Relational Operators Logical Operators Operator precedence Casting. Operators. Operators are special symbols used for:

I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.

## Chapter 2: Java Fundamentals

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.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
1. Chapter 2: Java Fundamentals Operators

2. Content • Group of Operators • Arithmetic Operators • Assignment Operator • Order of Precedence • Increment/Decrement Operators • Relational Operators • Logical Operators • Operator precedence • Casting

3. Operators • Operators are special symbols used for: • mathematical functions • assignment statements • logical comparisons • Examples of operators: • 3 + 5 // uses + operator • 14 + 5 – 4 * (5 – 3) // uses +, -, * operators • Expressions: can be combinations of variables and operators that result in a value

4. Groups of Operators • There are 5 different groups of operators: • Arithmetic Operators • Assignment Operator • Increment / Decrement Operators • Relational Operators • Logical Operators

5. Addition + Subtraction – Multiplication  Division / Remainder (modulus ) % Java Arithmetic Operators

6. Arithmetic Operators • The following table summarizes the arithmetic operators available in Java. This is an integer division where the fractional part is truncated.

7. Example Exampleof division issues: 10 / 3 gives 3 10.0 / 3 gives 3.33333 • As we can see, • if we divide two integers we get an integer result. • if one or both operands is a floating-point value we get a floating-point result.

8. Modulus • Generates the remainder when you divide two integer values. • 5%3 gives 2 5%4 gives 1 • 5%5 gives0 5%10 gives 5 • Modulus operator is most commonly used with integer operands. If we attempt to use the modulus operator on floating-point values we will garbage!

9. ( ) evaluated first, inside-out , /, or % evaluated second, left-to-right +,  evaluated last, left-to-right Order of Precedence

10. Allways it is a variable identifier. It is either a literal |a variable identifier |anexpression. Basic Assignment Operator • We assign a value to a variable using the basic assignment operator (=). • Assignment operator stores a value in memory. • The syntax is leftSide = rightSide ; Examples: i = 1; start = i; sum = firstNumber + secondNumber;avg = (one + two + three) / 3;

11. The Right Side of the Assignment Operator • The Java assignment operator assigns the value on the right side of the operator to the variable appearing on the left side of the operator. • The right side may be either: • Literal: ex. i = 1; • Variable identifier: ex. start = i; • Expression: ex. sum = first + second;

12. int firstNumber=1, secondNumber; firstNumber = 234; secondNumber = 87; secondNumber ??? A B secondNumber 87 firstNumber 234 Assigning Literals • In this case, the literal is stored in the space memory allocated for the variable at the left side. A. Variables are allocated in memory. firstNumber 1 B. Literals are assigned to variables. Code State of Memory

13. int firstNumber=1, i; firstNumber = 234; i = firstNumber; A B i 234 firstNumber 234 Assigning Variables • In this case, the value of the variable at the right side is stored in the space memory allocated for the variable at the left side. A. Variables are allocated in memory. firstNumber 1 i ??? B. values are assigned to variables. Code State of Memory

14. A first 1 second second 87 ??? sum sum 321 ??? B Assigning Expressions • In this case, the result of the evaluation of the expression is stored in the space memory allocated for variable at the left side. A. Variables are allocated in memory. int first, second, sum; first = 234; second = 87; Sum = first + second B. Values are assigned to variables. first 234 Code State of Memory

15. A B C number = 35; Updating Data A. The variable is allocated in memory. number ??? B. The value 237 is assigned to number. number 237 int number; number = 237; C. The value 35 overwrites the previous value 237. number 35 State of Memory Code

16. Example: Sum of two integer public class Sum { // main method public static void main( String args[] ){ int a, b, sum; a = 20; b = 10; sum = a + b; System.out.println(a + ” + ” + b + “ = “ + sum); } // end main } // end class Sum

17. Java allows combining arithmetic and assignment operators into a single operator: Addition/assignment += Subtraction/assignment = Multiplication/assignment = Division/assignment /= Remainder/assignment %= Arithmetic/Assignment Operators

18. It is either a literal |a variable identifier |anexpression. Arithmetic/Assignment Operators • The syntax is leftSide Op= rightSide ; • This is equivalent to: leftSide = leftSide Op rightSide ; • x%=5;  x = x % 5; • x*=y+w*z;  x = x*(y+w*z); Allways it is a variable identifier. It is an arithmetic operator.

19. Increment/Decrement Operators Only use ++ or  when a variable is being incremented/decremented as a statement by itself. x++; is equivalent to x = x+1; x--; is equivalent to x = x-1;

20. Pre-increment versus post-increment • If the unary increment operator, ++, is used after the operand, e.g. x++, it is called a postincrementoperator. • If the unary increment operator, ++, is used before the operand, e.g. ++x, it is called a preincrement operator.

21. Pre-increment versus post-increment It is important to note that when incrementing or decrementing a variable in a statement by itself, there is no difference between the pre and post forms of the operator. It is only when a variable occurs in the context of a larger expression, that the pre and post forms of the operator have a different effect.

22. Pre-increment versus post-increment if we include the statement ++x as part of a larger statement, e.g. • y = ++x; the effect is : • The value in x is incremented. • The new value x is stored in y.

23. Pre-increment versus post-increment x = 5; y = ++x; • After these statements are executed, x contains the value ?. • y contains the value ?.

24. Pre-increment versus post-increment x = 5; y = ++x; • After these statements are executed, x contains the value 6. • y contains the value 6.

25. Pre-increment versus post-increment However, if we include the statement x++ as part of a larger statement, e.g. • y = x++; the effect is somewhat different. • The old value of x is stored in y. • The value in x is incremented

26. Pre-increment versus post-increment x = 5; y = x++; • After these statements are executed, x contains the value ?. • y contains the value ?.

27. Pre-increment versus post-increment x = 5; y = x++; • After these statements are executed, x contains the value 6. • y contains the value 5.

28. Pre-increment versus post-increment int z = 2; System.out.println(z); System.out.println(z++); System.out.println(z); System.out.println(); z = 2; System.out.println(z); System.out.println(++z); System.out.println(z);

29. Pre-increment versus post-increment The output from this code would be: 2 2 3 2 3 3

30. Pre-increment versus post-increment • If the unary increment operator, ++, is used after the operand, e.g. x++, it is called a postincrement operator.

31. Pre-increment versus post-increment The unary decrement operator, −−, also has two forms: • postdecrement, x−− • predecrement, −−x

32. Pre-increment versus post-increment The unary decrement operator, −−, also has two forms: • postdecrement, x−− • predecrement, −−x The difference between the postdecrement and predecrement operators is the same as the difference between the postincrement and preincrement operators.

33. Pre-increment versus post-increment It is important to note that when incrementing or decrementing a variable in a statement by itself, there is no difference between the pre and post forms of the operator.

34. Pre-increment versus post-increment Increment the value in the integer variable x by 1 in four different ways. • x = x+1; • ++x; • x++; • x += 1;

35. Pre-increment versus post-increment What is the value in i and n after the following code snippet has been executed? int i=10; int n = i++ % 5;

36. Pre-increment versus post-increment What is the value in i and n after the following code snippet has been executed? int i=10; int n = i++ % 5; i has the value 11. n has the value 0.

37. Pre-increment versus post-increment What would be the effect of changing the postincrement operator to a preincrement operator? int i=10; int n = ++i % 5;

38. Pre-increment versus post-increment What would be the effect of changing the postincrement operator to a preincrement operator? int i=10; int n = ++i % 5; i has the value 11; n has the value 1;

39. Relational Operators • Relational operators compare two values • They Produce a boolean value (true or false) depending on the relationship

40. Example • int x = 3; • int y = 5; • boolean result; result = (x > y); • now result is assigned the value false because 3 is not greater than 5

41. Logical Operators Symbol Name && AND || OR ! NOT

42. Example boolean x = true; boolean y = false; boolean result; result = (x && y); result is assigned the value false result = ((x || y) && x); (x || y) evaluates to true (true && x) evaluates to true result is then assigned the value true

43. Operators Precedence

44. Type Conversion (Casting) • Used: • to change one data type to another . • to avoid implicit type coercion. • Syntax: (dataTypeName) expression • Expression evaluated first, then the value is converted to dataTypeName

45. Type Conversion (Casting) • Examples: • (int)(7.9 + 6.7) -> 14 • (int)(7.9) + (int)(6.7) -> 13 • (double)(17) -> 17.0 • (double)(8+3) > (double)11 ->11.0 • (double)(7) /2 = 7.0/2 -> 3.5 • (double)(7/2) = 3.0 • (int)(7.8+(double)(15)/2) -> (int)15.3 ->15

46. Type Conversion (Casting) (int)(‘A’) -> 65 (int)(‘8’) -> 56 (char)(65) -> ‘A’ (char)(56) -> ‘8’

47. Example -TRACE • This example further illustrates how assignment statements and input statements manipulate variables. Consider the following declarations: • intfirstNum;intsecondNum;charch;double z;Also suppose that the following statements execute in the order given:1. firstNum = 4;2. secondNum = 2 * firstNum + 6;3. z = (firstNum + 1) / 2.0;4. ch = 'A';5. firstNum = (int)(z) + 8;6. firstNum = secondNum-- ; • After statment 6

48. Data type compatibility • int x= 7.5; • int x = false; • int y=13 double z= y/2; • double z=13.0;int w=z/2; double z= (double)y/2; double w=z/2; int w = (int) z/2;

49. Implicit VS Explicit type conversions Implicit type conversions Explicit type conversions • An implicit conversion is where the conversion happens without any syntax. • e.g. inti = 999999999; double d = i; int x; char c='a';x=c; • double>int>long>short>byte • double>int>long>char • An explicit conversion is where you use some syntax to tell the program to do a conversion. • e.g. int x=97; char c=(char)x; inti = 999999999; byte b = (byte) i; int y=(int)7.5;