• Definitions:
  • An operator is a symbol indicating that an operation is to be performed on one or more operands
  • An operand can be a variable, literal, or expression
• Number of Operands:
  • A unary operator has one operand
  • A binary operator has two operands
  • A ternary operator has three operands
• Numeric Values:
  • Integer and floating-point numbers are both considered numeric values

• Infix Notation for Binary Operators:
  • Operand Operator Operand
• Postfix Notation for Binary Operators:
  • Operand Operand Operator
• Prefix Notation for Binary Operators:
  • Operator Operand Operand

• Other Names:
  • Prefix Notation is sometimes called Polish Notation
  • Postfix Notation is sometimes called Reverse Polish Notation
• Resulting Humor(?):
  • 
    (Courtesy of xkcd)

• Operands:
  • Numbers
• Result:
  • A number

• Numeric Operations and Operators:
  • Addition (+)
  • Subtraction (-)
  • Multiplication (*)
  • Division (/)
• Operands:
  • Good practice says both operands should be of the same numeric type
  • In fact, Java will widen in some circumstances
• Resulting Type:
  • When both operands have the same type then the result will also be of that type

Review:
Can you identify all of the statements?
Can you identify all of the expressions? (Be careful!)

• Integer Operations and Operators:
  • Integer Division (/)
  • Remainder (sometimes called modulo) (%)
• Operands:
  • int
• Resulting Type:
  • int

• / (in Java):
  • Results in the int value that corresponds to the truncation of the real-valued quotient (i.e., the quotient rounded towards 0)
• % (in Java):
  • The remainder after integer division, namely
    x - (x/y)*y
    where x is the dividend, y is the divisor, and / is the integer division operator
    (make sure you understand why x - (x/y)*y is not 0)

• Gaining Experience with Integer Division:
  • 11 / 3
  • 6 / 3
  • 2 / 3
• Gaining Experience with Remainders:
  • 11 % 3
  • 6 % 3
  • 2 % 3

• Two Options:
  1. Round to zero (i.e., truncation -- the result is closer to 0 than the quotient)
  2. Round toward negative infinity (i.e., floor -- the result is always less than or equal to the quotient)
• Positive Numbers:
  • The two options yield the same result
• Integer Division and Negative Numbers:
  1. -4/3 evaluates to -1
  2. -4/3 evaluates to -2
• Remainder and Negative Numbers:
  1. 4 mod -3 evaluates to 1; -4 mod 3 evaluates to -1; -4 mod -3 evaluates to -1
  2. 4 mod -3 evaluates to -2; -4 mod 3 evaluates to 2; -4 mod -3 evaluates to -1

• The Two Options Repeated:
  1. Round to zero (i.e., truncation -- the result is closer to 0 than the quotient)
  2. Round toward negative infinity (i.e., floor -- the result is always less than or equal to the quotient)
• The Two Options in Java (Starting in v8):
  1. / and %
  2. Math.floorDiv() and Math.floorMod()

• Operations and Operators:
  • "Positive" (+)
  • Negate/Negative (-)
• Operand:
  • A numeric type
• Result:
  • The result of multiplying the operand by +1 or -1, respectively (without changing the type)

• Operations and Operators:
  • Increment (++)
  • Decrement (--)
• Operand:
  • A numeric variable
• Result:
  • The result of adding +1 or -1 to the operand, respectively (without changing the type)
• Side Effect:
  • Increases or decreases the operand either before (in the case of ++x and --x) or after (in the case of x++ and x--) using it

• Precedence:
  • Controls the order in which operations are performed
• Associativity:
  • Specifies the order in which operations of the same precedence are performed (whether left-to-right or right-to-left)

• Level 1:
  • ++(post) --(post)
• Level 2:
  • ++(pre) --(pre) +(unary) -(unary)
• Level 4:
  • * / %
• Level 5:
  • +(binary) -(binary)
• Level 15:
  • =

• Binary Arithmetic Operators:
  • All have left-to-right associativity
• Unary Arithmetic Operators
  • Most have right-to-left associativity
  • Post-increment and post-decrement have left-to-right associativity

5 + 3 * 2

2 * 4 - 1

2 * (4 - 1)

2 + 8 + 3 - 2

8 * 4 * 2

8 / 4 / 2

• Motivation:
  • Numeric types in Java are unitless but expressions and statements often involve units
• The Practice:
  • Include the units in a comment above the statement

• An Example:
  • int i, j; i = 3 + (j = 5);
• The Result:
  • 5 is assigned to j and 8 is assigned to i
• Why it Should be Avoided:
  • In and of itself it's confusing
  • It can cause additional confusion in more complicated statements, especially those involving relational operators

• The Example:
  • int i, j; j = 0; i = 3 + j = 5; // Won't compile
• Why It Won't Compile:
  • + has the highest precedence so 3 + j is executed first and evaluates to 3 (a value)
  • The assignments are then evaluated right to left. So, 5 is assigned to 3 and 3 isn't a variable