Topics

Review

• Returning Values
• Return Type in Method Header
• Method Calls Can Be Expressions
• The main Method

New Material

• Getting Input from the Command Line
• Converting Strings to Integers
• Control Structures
• Conditionals or Branches
• The boolean Data Type
• Relational Operators
• if Statements
• if/else Statements
• Nested if Statements
• Should We Use Nested if Statements?
• if/ else if Statements

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

Returning Values

• When a method creates a value and sends it back to the the method call, we say it is returning a value
• This is done with a return statement which has the following format

  
  return EXPRESSION

• When the java interpreter comes to a return statement it does the following
  • Causes the running of the method to stop
  • Sends the value of EXPRESSION back to the method call
• So a method stops running when it gets to a return statement

Return Type in Method Header

• The method header has to specify the kind of value each method returns
• It does this using the return type that appears in the method header right before the method name
• Even if the method does not return a value, it still needs a return type
• The return type for a method that returns nothing is void

Method Calls Can Be Expressions

• Methods that have a return statement provide a value to the method call
• We call anything that can be turned into a value an expression
• So a call to a method that returns a value is also an expression
• So an expression can be
  • A literal
  • A variable
  • A calculation with operators
  • A call to a method that returns a value

The main Method

• The real work in Java programs is done by methods
• A well written program breaks a big problem down into a number of methods
• The main method then calls the methods to do the work required
• If the method names are well chosen, simply reading the method calls in the main method gives a good idea of what the program does
• The main method in Java is special
• All other methods have to be called to run
• Not the main method
• It is automatically called when you run the Java file
• You cannot run a Java file if it does not have a main method
• The method drives the work of the program

New Material

Getting Input from the Command Line

• The programs you have seen up to now always produced the same results
• That's because they had no way to change values inside the code
• There are a number of ways that Java programs can get input from the user
• Today you will see the easiest way to do this
• Unix commands allow you to give them information on the command line
• If I wanted to list the contents of my tmp directory I would write

  ls tmp

• "tmp" is an example of a command line argument
• We can do the same with Java programs
• Look at the header for the main method

  public static void main(String[] args)

• main has the single parameter args
• The data type String[] means it is an array of strings
• We'll discuss arrays in a few classes
• But basically arrays are lists of things
• args contains all the command line arguments used when running the program
• Since there can be many command line arguments, we have to specify which argument we want
• To get the first command line argument use

  args[0]

• The following code uses this feature

  	
  public class CommandLineInput {
      public static void main (String[] args){
          System.out.println(args[0]);
      }
  }

• Here is what happens when we run the code with different arguments

  $ java CommandLineInput Mercury
  Mercury
  
  $ java CommandLineInput Venus
  Venus
  
  $ java CommandLineInput Earth
  Earth
  
  $ java CommandLineInput Mars
  Mars

Converting Strings to Integers

• The args parameter in the main lets a Java program use command line arguments
• But command line arguments are strings
• What if we need an integer instead?
• We need a way to convert a string value into a number
• You can do that in Java, but the code to do this looks strange
• If I wanted to convert the String variable input into an integer I would write

  Integer.parseInt(input);

• Don't worry about why it has to be done this way
• The reason has to do with the object oriented nature of Java
• It will be explained in future classes
• Here is a simple Java program that takes a command line argument
• Converts it into an integer
• And doubles it

  public class Double {
      public static void main (String[] args){
          String input;
          input = args[0];
          System.out.println("input: " + input);
          int number;
          number = Integer.parseInt(input);
          System.out.println("number: " + number);
          System.out.println("number * 2: " + number * 2);
      }
  }

• Running this program several times we get

  $ java Double 3
  input: 3
  number: 3
  number * 2: 6
  
  $ java Double 4
  input: 4
  number: 4
  number * 2: 8
  
  $ java Double 5
  input: 5
  number: 5
  number * 2: 10

Control Structures

• When a program runs, its statements are executed in a particular order
• This order is called the flow of control
• Or the path of execution
• The usually the order in which statements are executed is simple
• Start at the top and execute every statement
• Until the bottom is reached
• Control structures are features of a computer languages that allow for a different order of execution
• There are two types of control structures
  • Loops
  • Conditionals or Branches

Conditionals or Branches

• Conditional control structures are like switches on a railroad track
• Which path the train takes depends on how the switch is set
• When the java interpreter comes across a conditional statement it has to make a decision
• It has to decide what statements to execute next
• Usually it makes this decision by evaluating an expression whose only possible values are true and false
• There are four conditionals in Java
• But for the moment we will only consider three
  • The if statement
  • The if/else statement
  • The if/else if statement

The boolean Data Type

• A variable of type boolean can only have the values true or false
• The name comes from the British mathematician George Boole who invented this field of mathematics
• A boolean expression is an expression whose only possible values are true and false
• There are two boolean literals
  • true
  • false

Relational Operators

• All if statements evaluate boolean expressions
• Usually, these expressions involve relational operators
• Relational operators compare two boolean values
• And return either true or false
• The format for a relational expression is

  
  BOOLEAN_VALUE  RELATIONAL_OPERATOR  BOOLEAN_VALUE

• Java provides the following relational operators

  Operator	Meaning	Example	Value
  ==	equal to	2 + 2 == 4	true
  !=	not equal to	3.2 != 4.1	true
  <	less than	4 < 3	false
  >	greater than	4 > 3	true
  <=	less than or equal to	2 <= 0	false
  >=	greater than or equal to	2.4 >= 1.6	true

• Notice that the equality operator is  == 
• Not =
• This is a mistake that is easy to make
• And you will probably make it often as you write Java programs

if Statements

• The simplest conditional control structure is the if statement
• An if statement contains other statements inside it
• These statements are only run if certain conditions are met
• It has the following format

  if (CONDITION){
      STATEMENT
      STATEMENT
      ...
   }

• The CONDITION is a boolean expression
• The statements inside the code block are run if the CONDITION is true
• If not, the statements are skipped
• Here is an example

  public class Odd {
      public static void main (String[] args){
          for (int num = 1; num <= 10; num++){
              odd(num);
          }
      }
  
      public static void odd (int number){
          if (number % 2 == 1 ){
              System.out.println(number + " is odd ");
          }
      }
  }

• Here the relational operator is <=
• When we run this code we get

  $ java Odd
  1 is odd 
  3 is odd 
  5 is odd 
  7 is odd 
  9 is odd

if/else Statements

• In an if statement the statements inside the code block are run if the boolean expression in the header is true
• Otherwise the code block is skipped
• And execution resumes with the first statement after the code block
• So with an if statement there are two choices
  • Run the statements in the code block
  • Skip over the statements in the code block
• With an if/else statement you have two choices
  • Run the statements in the code block after if
  • Run the statements in the code block after else
• An if/else statement has the following format

  
  if (CONDITION){
      STATEMENT;
      STATEMENT;
      ...
  } else {
      STATEMENT;
      STATEMENT;
      ...
  }

• Here is an example

  	
  public class OddEven {
      public static void main (String[] args){
          for (int num = 1; num <= 10; num++){
              odd_even(num);
          }
      }
  
      public static void odd_even (int number){
          if (number % 2 == 1 ){
              System.out.println(number + " is odd ");
          } else {
              System.out.println(number + " is even ");
          }
      }
  }
  

• When we run this we get

  $ java OddEven
  1 is odd 
  2 is even 
  3 is odd 
  4 is even 
  5 is odd 
  6 is even 
  7 is odd 
  8 is even 
  9 is odd 
  10 is even 

Nested if Statements

• if statements are compound statements
• That means they can have statements inside them
• An if statement is a statement
• So you can have an if statement inside an if statement
• Just like you can have a for statement inside a for statement
• This called a nested if statement
• As an example, thinking about a method that will turn a score from 0 to 100 into a letter grade
• Each range of scores corresponds to a letter grade

  100 - 90    A
  89  - 80    B
  79  - 70    C
  69  - 60    D
  59  - 0     F

• The method will get the score as a parameter
• Then find the appropriate range of values
• And return the proper letter grade
• Here is code to do this

  public class Grades {
      public static void main (String[] args){
          public static void main (String[] args){
              String input = args[0];
              int score = Integer.parseInt(input);
              System.out.println("A score of " + score + " gets a grade of " +  grade(score));
      }
  
      public static String grade(int score){
          if (score >= 90){
              return "A";
          } else {
              if (score >= 80) {
                  return "B";
              } else {
                  if (score >= 70){
                      return "C";
                  } else {
                      if (score >= 60){
                          return "D";
                      } else {
                          return "F";
                      }
                  }
              }
          }
      }
  }
  

• When we run this we get

  $ java Grades
  91 A
  83 B
  78 C
  65 D
  59 F

Should We Use Nested if Statements?

• The code above works, but it looks odd
• As it goes down the list of possible values, the code shifts more and more to the right
• That is not too much of a problem here
• But the grading system for this course uses plus and minus letter grades

• 100 - 93    A
  92  - 90    A-
  89  - 86    B+
  85  - 83    B
  82  - 80    B-
  79  - 76    C+
  75  - 73    C
  72  - 70    C-
  69  - 66    D+
  65  - 63    D
  62  - 60    D-
  59  - 0     F

• We would need many many nested if statements
• And if you indented them properly you might not fit all of them in your window
• An if/else statement only has two branches
• What we need is a a conditional statement that has many branches

if/ else if Statements

• An if/else if statement gives us many different paths through the code
• It has the form

  if (BOOLEAN_EXPRESSION_1) {
      STATEMENT;
      ...
  } else if (BOOLEAN_EXPRESSION_2) {
      STATEMENT;
      ...
  ...
  [ else {
      STATEMENT;
      ...
  {

• If we rewrite the grading code above using if/else if statements it would look like this

  	
  public class Grades2 {
      public static void main (String[] args){
          String input = args[0];
         int score = Integer.parseInt(input);
         System.out.println("A score of " + score + " gets a grade of " +  grade(score));
      }
  
      public static String grade(int score){
         if (score >= 90){
              return "A";
         } else if (score >= 80) {
              return "B";
         } else if (score >= 70){
              return "C";
         } else if (score >= 60){
              return "D";
         } else {
              return "F";
         }
      }
  }
  

• Notice how much cleaner this code looks
• There are two important things to keep in mind about if/else if statements
  • You can have as many if/else if clauses as you like
  • A final else clause is optional
• There is no limit to the number of if/else if clauses
• But each must have its own boolean expression
• The final else clause is optional

Class Quiz

Attendance

Class Exercise