Topics

Review

• Relational Operator Precedence
• Mathematical Methods in Math
• Math Constants
• Casting

New Material

• Different Types of Operators
• Logical Operators
• Truth Tables
• Short-Circuit Evaluation
• Precedence of Logical Operators
• Conditional Loops
• The While Loop
• The do/while Loop
• Infinite Loops

Homework 5

Homework 5 is due this Sunday at 11:59 PM.

You will find the assignment here.

If you have a problem or a question, make a post on the Class Discussion Area.

Review

Relational Operator Precedence

• Here is a more complete listing of operator precedence showing where the relational operators fit n=in

  Description	Operators
  Unary operators	++ --
  Multiplicative operators	* / %
  Additive operators	+ -
  Relational operators	< > <= >=
  Equality operators	== !=

Mathematical Methods in Math

• Math contains many other useful mathematical methods
• Here is a partial list

  Method	What it does
  Math.abs()	Absolute value
  Math.max()	The greater of two numbers
  Math.min()	The lesses of two numbers
  Math.sqrt()	Square root
  Math.cbrt()	Cube root
  Math.random()	A random number between 0.0 and 1.0
  Math.log()	Natural logarithm
  Math.log10()	Base 10 logarithm
  Math.cos()	Cosine
  Math.sin()	Sine
  Math.tan()	Tangent

Math Constants

• In addition to math methods, Math also contains constants

  Constant	What it is
  Math.PI	π - The ratio of the circumference of a circle to its diameter
  Math.E	e - The base of the natural logarithms

Casting

• Java is a strongly typed language
• Scripting languages like Python are flexible about data types
• But Java is not
• Python recognizes different data types
• But it has methods that will turn one data type into another
• Java uses a different approach
• You can force a variable of one data type to behave like another by using a cast
• It uses the following format

  
  (DATA_TYPE) EXPRESSION

• So if the variable num was a double but I needed an int I would write

  (int) num

New Material

Different Types of Operators

• Up to this point we have talked about two groups of operators
• The arithmetic operators
  • +
  • -
  • *
  • /
  • %
  work on numbers
• And produce numbers as results
• The relational operators
  • >
  • <
  • >=
  • <=
  • ==
  • !=
  also work on numbers
• But they produce boolean results
• Logical operators work on boolean values
• And produce boolean values as a result

Logical Operators

• The logical operators are
  • && (and)
  • || (or)
  • ! (not)
• The && (and) operator returns true if both its operands are true

  5 > 4 && 4 > 2 : true

• If either of its two operands are false, && returns false

  5 > 4 && 4 < 2 : false

• It also returns false if both its operands are false

  5 < 4 && 4 < 2 : false

• The || (or) operator returns true if either of its operands are true

  5 > 4 || 4 < 2 : true

• It only returns false if both of its operands are false

  5 < 4 || 4 < 2: false

• The ! (not) operator takes only one operand and reverses its value
• So true becomes false

  ! 5 > 4: false

• And false becomes true

  ! 5 < 4: true

Truth Tables

• To show how the logical operators work we use truth tables
• Truth tables have multiple columns
• The first one or two columns are values of boolean variables
• The last column shows the boolean result of running the operator on the values
• Here is the truth table for && (and)

  p	q	p && q
  true	true	true
  true	false	false
  false	true	false
  false	false	false

• The truth table for || (or)

  p	q	p || q
  true	true	true
  true	false	true
  false	true	true
  false	false	false

• And the truth table for ! (not)

  p	! p
  true	false
  false	true

Short-Circuit Evaluation

• Let's say you had a boolean expression like this

  a > b  && c > d

• If the first expression is false the result of the entire expression will be false
• Because both must be true for && to return true
• Similarly, if we have the expression

  a > b  || c > d

  and the first expression is true, the result of the whole expression will be true
• Again, the second value cannot change the outcome
• In both cases the Java interpreter will not evaluate the second operand
• Because it cannot change the result
• And it wastes time
• This is called short-circuited evaluation
• Another term for this feature is lazy evaluation
• This makes the Java interpreter more efficient

Precedence of Logical Operators

• When we write an expression like

  a + b > c and c * d < a

  there are three different kind of operators
  • Arithmetic - +, *
  • Relational - >, <
  • Logical - and
• Operator precedence determines which operators are used before other operators
• The logical operators are and, or and not
• They have lower precedence than arithmetic operators
• They also have lower precedence than the relational operators
• The order of precedence is

  !	Logical NOT
  *   /   %	Multiplication, division and remainder
  +  -	Addition and subtraction
  >   <   >=   <=	Relational Operators
  ==   !=	Equality Operators
  &&	Logical AND
  ||	Logical OR

Conditional Loops

• In the Dice program we simulated several rolls of dice
• What if we wanted to simulate a game where the play continued until someone rolled a 7?
• We would need a loop that kept going until the total on the two dice was 7
• We can't do this with a for loop
• A forloop is a counted loop
• In the program Dice it it will alway loop 10 times
• We need a loop that will stop after something happens
• We need a conditional loop

The While Loop

• The while loop has the following format

  
  while (BOOLEAN_EXPRESSION){
      STATEMENT;
      STATEMENT;
      ...
  }

• When the java interpreter comes to a while loop it evaluates the BOOLEAN_EXPRESSION
• If it is true it runs the code in the loop body
• Then it evaluates the BOOLEAN_EXPRESSION again
• It will keep running as long as the expression is true
• Here is the program to simulate the dice game mentioned above

  public class DiceGame {
      public static void main (String[] args){
          int die_1 = rand_int(7, 1);
          int die_2 = rand_int(7, 1);
          int total = die_1 + die_2;
          System.out.println(die_1 + " " + die_2 + " -> " + total);
          while (total != 7){
              die_1 = rand_int(7, 1);
              die_2 = rand_int(7, 1);
              total = die_1 + die_2;
              System.out.println(die_1 + " " + die_2 + " -> " + total);
          }
          System.out.println("Game over");
      }
  
      public static int rand_int(int max, int min){
          double value = Math.random() * (max - min)  + min;
          return (int) value;
      }
  }

• When run, we get

  $ java DiceGame 
  5 1 -> 6
  4 5 -> 9
  2 3 -> 5
  5 5 -> 10
  3 5 -> 8
  5 2 -> 7
  Game over

The do/while Loop

• The code above works, but it is not as good as it could be
• Notice that three lines of code are are repeated

          int die_1 = rand_int(7, 1);
          int die_2 = rand_int(7, 1);
          int total = die_1 + die_2;
          ...
          while (total != 7){
              die_1 = rand_int(7, 1);
              die_2 = rand_int(7, 1);
              total = die_1 + die_2;

• This violates a basic principle of programming
• Don't repeat yourself, often abbreviated DRY
• Repetition wastes your time and can lead to problems
• What if fix a problem in the repeated code in one place
• But forget to do it in another?
• But here we can use the other conditional loop in Java
• The do/while loop
• It has the following format

  
  do {
      STATEMENT;
      STATEMENT;
      ...
  }
  while (BOOLEAN_EXPRESSION);

• The difference between the do/while and the while loop is when the boolean expression is evaluated
• In a while loop the code block is only executed if the boolean expression is true
• That means we test before running the loop code
• With ado/while loop the loop body is always executed at least once
• But it will not be run again unless the boolean expression is true
• Here is a revised version of DiceGame using a do/while loop

  public class DiceGame2 {
      public static void main (String[] args){
          int die_1, die_2, total;
          do {
              die_1 = rand_int(7, 1);
              die_2 = rand_int(7, 1);
              total = die_1 + die_2;
              System.out.println(die_1 + " " + die_2 + " -> " + total);
          } 
      while (total != 7);
          System.out.println("Game over");
      }
  
      public static int rand_int(int max, int min){
          double value = Math.random() * (max - min)  + min;
          return (int) value;
      }
  }

• Running the code we get

  $ java DiceGame2
  3 3 -> 6
  2 2 -> 4
  2 5 -> 7
  Game over

Infinite Loops

• Conditional loops keep going until their boolean expression becomes false
• That means something has to happen in the loop body to make this happen
• If this does not happen the loop will go on forever
• This is called an infinite loop
• When this happens on hold down the Control key while pressing C key

Class Quiz

Attendance

Class Exercise