Copyright © 2013
Robert W. Hasker

More Object-Oriented Programming

• Ch. 6

Scope

• Local variable: variable defined within a method
• Consider the UML diagram (from the Enterprise Architect project file quadcopter.eap)
   
  The corresponding class:

          public class Quadcopter
          {
             private double xLocation, yLocation, xDestination, yDestination;
             private double maxSpeed;
  
             public void setLocation(double x, double y)
             {
                xLocation = x;
                yLocation = y;
             }
  
             public void setDestination(double x, double y)
             {
                xDestination = x;
                yDestination = y;
             }
  
             public double getXDestination()
             {
                return xDestination;
             }
  
             public double getYDestination()
             {
                return yDestination;
             }
  
             public void setMaxSpeed(double maxSpeed)
             {
                this.maxSpeed = maxSpeed;
             }
  
             public void getMaxSpeed()
             {
                return maxSpeed;
             }
  
             public double distanceToDestination()
             {
                double dx = xLocation - xDestination;
                double dy = yLocation - yDestination;
                double dist = Math.sqrt(dx * dx + dy * dy);
                return dist;
             }
  
             public double timeToDestination()
             {
                double distToTravel = distanceToDestination();
                double time = distToTravel / maxSpeed;
                return time;
             }
          }
  

  • Suppose we rewrite setLocation as follows:

               // WRONG!!
               public void setLocation(double x, double y)
               {
                  double xLocation = x;
                  double yLocation = y;
               }
    

    • Each time introduce braces, get a new "context"
      • Known as a block
    • scope: area where data is visible
    • within methods, scope is from point of declaration to end of enclosing block
    • cannot declare variable twice with same scope - illegal:

                 public double dist()
                 {
                    double d = xLocation - xDestination;
                    double d = yLocation - yDestination;
                    ...
                 }
      

      but could write something like

                 public double dist()
                 {
                    if ( xLocation > yLocation )
                    {
                       double d = xLocation - xDestination;
                       ...
                    }
                    else
                    {
                       double d = yLocation - yDestination;
                       ...
                    }
                 }
      

    • Variables within a method are said to be local
    • Parameters are effectively declared from the beginning of the method to the end
  • Can return from anywhere in a method:

               public double timeToDestination()
               {
                  if ( maxSpeed < 1e-4 )
                  {
                     // force VERY long time to get there
                     return distToTravel / 1e-30;
                  }
                  double distToTravel = distanceToDestination();
                  double time = distToTravel / maxSpeed;
                  return time;
               }
      

    • This is rare - generally have just one return
    • Note void methods can also have returns:

                 public void setMaxSpeed(double maxSpeed)
                 {
                    if ( maxSpeed < 0.0 )
                    {
                       System.err.println("Illegal max speed.");
                       return;
                    }
                    this.maxSpeed = maxSpeed;
                 }
      

      • Also to be avoided!

Argument Passing

• Consider the following version of setMaxSpeed:

             public void setMaxSpeed(double maxSpeed)
             {
                if ( maxSpeed <= 0.0 )
                   maxSpeed = 1.0;
                this.maxSpeed = maxSpeed;
             }
  

  Code in main:

             double spd = in.nextDouble();
             Quadcopter qc = new Quadcopter();
             qc.setMaxSpeed(spd);
  

  • int, double, other simple data types: pass-by-value

More terms

• accessor methods: methods like getXLocation() which return the value of an attribute
  • Also known as "getter" methods
  • Important design consideration: don't mix printing with accessors:

               // BAD!
               public double getXLocation()
               {
                  System.out.println("X location: " + xLocation);
                  return xLocation;
               }
      
    

• mutator methods: change value

             public void setLocation(double x, double y)
             {
                xLocation = x;
                yLocation = y;
             }
  

  • Also known as "setter" methods
  • Again, don't mix in output
• boolean methods: return true or false:

             public boolean isNearDestination()
             {
                double dist = distanceToDestination();
                return Math.abs(dist) < 5.0;
             }
  

  • Usage:

               if ( copter.isNearDestination() )
                  System.out.println("Watch out!");
    

  • Convention: use is in front of boolean method names

Example

• Student class: name, id, grade points, totalCredits, localPhoneNumber
• gpa(), handling case where totalCredits is zero
• postGrade(String grade, int credits)
• readLocalNumber: read, requiring XXX-YYYY format
• boolean isOnProbation: gpa below 2.0

Review

• scope, block, local variables, arguments
• more on return
• pass-by-value
• accessor, mutator methods (getters, setters)
• boolean methods: start name with is