Lecture 10
Instructor: Craig Duckett
Announcements
Assignment 1 Revision
DUE TONIGHT, April 27th,
In StudentTracker by midnight
If you have not yet submitted an Assignment 1, this is your last
chance to do so to earn points, otherwise you will get a zero, and I
hate doing that!
Assignment Dates (By Due Date)
• Assignment 1 Revision (LECTURE 10)
TONIGHT Wednesday, April 27th
• Assignment 2 Revision (LECTURE 12)
•
•
•
•
The Fickle
Finger of Fate
Wednesday, May 4th
Assignment 3 (LECTURE 13)
Monday, May 9th
Assignment 3 Revision (LECTURE 16)
Wednesday, May 18th
Assignment 4 (LECTURE 19)
Wednesday, June 1st
Assignment 4 Revision(LECTURE 20)
Monday, June 6th
3
But First…
The Quiz!
Mid-Term Post-Mortem
TODAY BEGINS THE SECOND HALF OF THE QUARTER -WHAT DOES THIS MEAN IN THE COSMIC SCHEME OF THINGS?
•
•
•
Less Theory, More Hands-On Work
(Less means Less, not No)
Less Hand-Holding, More Trial-and-Error
Less Explanation, More Research & Investigation, More Poking Around For Code, More
“Googling It” and More (on occassion) Aggravation. Grrrr!
When You Do Get Aggravated: Remember to STEP AWAY from your code occasionally, take a
break, walk around, go and eat, contemplate the great outdoors, then come back. If it is late at
night, go to bed. You may discover that bizarre thing that sometimes can happen, where you
DREAM IN CODE, and wake up in the morning refreshed and with the beginnings of a solution!
INPUT: Scanner Class REVIEW
import java.util.Scanner;
or
import java.util.*;
Scanner keyboard = new Scanner(System.in);
nextInt()
Assumes there is an int and does something with it
hasNextInt()
Checks to see if there is an int (boolean true or
false)
nextLine()
Replaces the int in the keyboard buffer with a
newline character (Enter) so the program won't use
the int again
Input
The Scanner Class
 To read input from the keyboard we use the Scanner class.
 Like Random, the Scanner class is defined in the Java Library
package called java.util, so we must add the following statement at
the top of our programs that require input from the user:
import java.util.*; // <-- I usually do this
or
import java.util.Scanner;
https://docs.oracle.com/javase/7/docs/api/java/util/package-summary.html
The Scanner Class
 Scanner objects work with System.in
 To create a Scanner object:
Scanner keyboard = new Scanner(System.in);
NOTE:
Like any other object, keyboard here is just a name “made up” by the coder and can
be called anything instead—input, feedIine, keyIn, data, stuffComingFromTheUser,
etc.—although it should represent a word most apt to its purpose.
In this case I am using the name keyboard since it seems apt as I’ll be using the
keyboard to enter data (i.e., do the input)
New Scanner Methods
 These are for ints (integers). There are also Scanner methods available
for floats, etc, which we'll see later on in the quarter 
 nextInt()
 Assumes there is an int and does something with it
 hasNextInt()
 Checks to see if there is an int (boolean true or false)
 nextLine()
 Replaces the int in the keyboard buffer with a newline character (Enter) so
the program won't use the int again
Okay: Let's have a look at the Basic_Keyboard_IO.java program from the
previous lecture 
What We're Going Over Today
• Today we're going to have a closer look at
parameters and arguments
• We're also going to look at
instance variables
• You should have enough coding behind you by the end of the lecture
today to successfully complete the coding for Assignment 3 “The
Maze”:
• Successfully Navigate through the Maze from start to finish using
various logic
• Use "instance variables" to set up the counters and be able to
collect the number of moves made, how many times the robot
moved in any particular direction, and then print out the various
totals at the end of the program.
More Flexible Methods
More Flexible Methods
The Way We Originally Learned (“Hard Coded”)
public void move2()
{ this.move();
this.move();
}
public void move3()
{ this.move();
this.move();
this.move();
}
public void move4()
{ this.move();
this.move();
this.move();
this.move();
}
A More Flexible Way (“Argument Coded”)
public void howManyMoves(int numMoves)
 New Flexible Method
{ int counter = 0;
while(counter < numMoves)
{ this.move();
counter++;
} // Note: This method has no error handling
}
How it might be called in main 
or 
or 
or 
karel.howManyMoves(2);
karel.howManyMoves(3);
karel.howManyMoves(4);
karel.howManyMoves(12);
Argument, Pass,
Parameter
Chapter 4.6: Using Parameters
You’ll notice that every new method (service) we’ve created does
something:
Each time we call upon one of those services, it’ll always do the same thing
public void turnAround()
{ this.turnLeft();
this.turnLeft();
}
public void move3()
{ this.move();
this.move();
this.move();
}
public void turnRight()
{ this.turnAround();
this.turnLeft();
}
We could have asked for user input, but
then the service would fill TWO roles
1. Doing <something>
2. Interacting with the user
We'd like each service to have a single, welldefined, and easy to summarize role
Thus, things like moveMultiple should move
the robot through multiple intersections
Things like main should run the part of the
program that relays instructions from the
user to the robot(s)
Chapter 4.6: Using Parameters
We need a way to pass information to a method or service.
We’d like to be able to say:
rob.moveMultiple(3);
or
rob.moveMultiple(7);
or even
Scanner keyboard = new Scanner(System.in);
int howFar = keyboard.nextInt();
rob.moveMultiple(howFar);
The actual info being passed to the method is called an ARGUMENT
The method must also be told to expect this information AND make room for it to
be stored somewhere in memory, so instead of:
public void moveMultiple()
we'll write
public void moveMultiple(int someNumber)
Chapter 4.6: Using Parameters
For integers ints, this creates (within moveMultiple) a COPY of whatever
we put inside the parentheses in main.
Inside of the moveMultiple() method someNumber behaves just like any other int
variable. We can print it out, assign new values to it, use it in a while loop, etc.
The thing that tells the method service to expect some info is called a
PARAMETER.
Let’s have a look how this works…
Arguments and Parameters
A method in new class up top:
PARAMETER
moves
counter
PASS
public void moveMultiple(int moves)
{
int counter = 0;
while(counter < moves)
{
move();
counter++;
}
}
In main below:
Scanner keyboard = new Scanner(System.in);
int howFar = keyboard.nextInt();
rob.moveMultiple(howFar);
ARGUMENT
howFar
Chapter 4.6: Using Parameters
Suppose we want a subclass of Robot that can easily tell us if it has gone
past a particular Avenue, for example Avenue 18...
We could use a getAvenue method and “hard-code” compare it to 18:
if(this.isPastAvenue == 18)
{// what to do when the robot has strayed too far}
but our code is more self-documenting with a predicate:
if(this.isPastAvenue(18)) // The coder supplies 18 here
{// what to do when the robot has strayed too far}
// or better yet:
if(this.isPastAvenue(anAvenue)) // The user supplies 18, or 22, or 66, etc.
// using the Scanner class and System.in input
{// what to do when the robot has strayed too far}
The isPastAvenue method is written as follows:
private boolean isPastAvenue(int anAvenue) // either way this is used
{ return this.getAvenue() > anAvenue;
// the same and with any
}
// number being entered
In main you’d call it this way: this.isPastAvenue(anAvenue);
Using a While Statement with a Parameter
The following method moves a robot east to Avenue 18.
public void moveToAvenue18() // <-- no parameter
{ while(this.getAvenue() < 18)
{ this.move();
}
}
This is very limited, and only useful to move the robot specifically
to Avenue 18 since it was “hard-coded” to do so. With a parameter,
however, it can be used to move the robot to any avenue east of its
current location.
public void moveToAvenue(int destAve) // with parameter
{ while(this.getAvenue() < destAve)
{ this.move();
}
}
In main you’d call it this way: this.moveToAvenue(18);
In main you’d call it this way:
Chapter 6.2.2: Reviewing Parameter Variables
In this section, we will show how parameter variables are closely related
to temporary variables, explore using parameters with constructors, and
discuss overloading.
Parameter Variables versus Temporary Variables
public void moveTheBot()
{ int howFar = 2; // <-- temporary variable
this.street = this.street + howFar;
}
In main you’d call it this way: this.moveTheBot();
public void moveTheBot(int howFar) // <-- parameter variable
{ this.street = this.street + howFar;
}
In main you’d call it this way: this.moveTheBot(howFar);
In main you’d call it this way: this.moveTheBot(2);
EXAMPLE
Method Without a Parameter Argument
public void moveMultiple()
{
this.move();
this.move();
this.move();
this.move();
this.move();
}
Main
rob.moveMultiple(); // rob will move 5 times
EXAMPLE
Method Without a Parameter Argument
public void moveMultiple()
{
int counter = 0;
while( counter < 5)
{
if(this.frontIsClear())
{
this.move();
counter = counter + 1; // This is the same as counter++;
}
}
}
Main
rob.moveMultiple(); // rob will move 5 times
EXAMPLE
Method Without a Parameter Argument
public void moveMultiple()
{
int counter = 0;
while( counter < 5) // 5 is “hard-coded” here, so easier to change at
{
// this coded location but there is a better solution
if(this.frontIsClear())
{
this.move();
counter = counter + 1;
}
}
}
Main
rob.moveMultiple(); // rob will move 5 times, and only 5 times
EXAMPLE
Method with Parameter Argument
public void moveMultiple(int numberOfIntersections) // declare and add argument
{
int counter = 0;
while( counter < numberOfIntersections) // replace 5 with that argument
{
if(this.frontIsClear())
{
this.move();
counter = counter + 1;
}
}
}
Main
rob.moveMultiple(5); // <-- 5 is placed within the method call as an argument
//
//
//
//
//
The 5 is still being “hard-coded” but this time as a parameter argument
instead of an integer defined inside the method. This makes it easier since
different numbers can now be called when the method is used, but why not
free up the method to call up ANY input actually entered by the user? That
way no number is being “hard-coded” before the program is compiled and run
EXAMPLE
Method with Parameter Argument
public void moveMultiple(int numberOfIntersections) // declare and add argument
{
int counter = 0;
while( counter < numberOfIntersections) // replace 5 with that argument
{
if(this.frontIsClear())
{
this.move();
counter = counter + 1;
}
}
}
Main
System.out.println("How many intersections forward would you like the robot to go?");
if( keyboard.hasNextInt()) // hasNextInt checks the input is an integer
{
int numMoves = keyboard.nextInt();
// nextInt puts it into memory container
System.out.println ("You entered a " + numMoves + "."); // called numMoves
this.moveMultiple(numMoves);
}
LET’S HAVE A CLOSER LOOK 
EXAMPLE
Method
public void moveMultiple(int numberOfIntersections)
{
int counter = 0;
while( counter < numberOfIntersections)
{
if(this.frontIsClear())
{
this.move();
counter = counter + 1;
}
numberOfIntersections
0
counter
}
}
Main
System.out.println("How many intersections forward would you like the robot to go?");
if( keyboard.hasNextInt() )
{
int numMoves = keyboard.nextInt();
System.out.println ("You entered a " + numMoves + ".");
this.moveMultiple(numMoves);
}
EXAMPLE
Method
public void moveMultiple(int numberOfIntersections)
{
int counter = 0;
while( counter < numberOfIntersections)
{
if(this.frontIsClear())
{
this.move();
counter = counter + 1;
numberOfIntersections
0
counter
}
}
}
Main
numMoves
System.out.println("How many intersections forward would you like the robot to go?");
if( keyboard.hasNextInt() )
{
int numMoves = keyboard.nextInt();
System.out.println ("You entered a " + numMoves + ".");
this.moveMultiple(numMoves);
}
EXAMPLE
Method
public void moveMultiple(int numberOfIntersections)
{
int counter = 0;
while( counter < numberOfIntersections)
{
if(this.frontIsClear())
{
this.move();
counter = counter + 1;
}
numberOfIntersections
0
counter
}
}
5
Main
numMoves
System.out.println("How many intersections forward would you like the robot to go?");
if( keyboard.hasNextInt() )
{
int numMoves = keyboard.nextInt();
System.out.println ("You entered a " + numMoves + ".");
this.moveMultiple(numMoves);
}
EXAMPLE
Method
public void moveMultiple(int numberOfIntersections)
{
int counter = 0;
while( counter < numberOfIntersections)
{
if(this.frontIsClear())
{
this.move();
counter = counter + 1;
}
numberOfIntersections
0
counter
}
}
5
Main
numMoves
System.out.println("How many intersections forward would you like the robot to go?");
if( keyboard.hasNextInt() )
{
int numMoves = keyboard.nextInt();
// nextInt actually gets the input
System.out.println ("You entered a " + numMoves + ".");
this.moveMultiple(numMoves);
}
EXAMPLE
Method
public void moveMultiple(int numberOfIntersections)
{
int counter = 0;
while( counter < numberOfIntersections)
{
if(this.frontIsClear())
{
this.move();
counter = counter + 1;
}
5
numberOfIntersections
0
counter
}
}
5
Main
numMoves
System.out.println("How many intersections forward would you like the robot to go?");
if( keyboard.hasNextInt() )
{
int numMoves = keyboard.nextInt();
System.out.println ("You entered a " + numMoves + ".");
this.moveMultiple(numMoves);
}
Method
Overloading
Test()
Test(int x)
Test(int x, int y)
Chapter 6.2.2: Overloading
In Java it is possible to define two or more methods within the same class that share
the same name, as long as their parameter declarations are different. When this is the
case, the methods are said to be overloaded, and the process is referred to as
method overloading. Method overloading is one of the ways that Java implements
polymorphism. Polymorphism is the ability of an object to take on many forms, and uses the
“is a” test determine multiple inheritance through from different classes, subclasses, etc.
Method overloading is one of Java's most exciting and useful features. When
an overloaded method is invoked, Java uses the type and/or number of arguments as
its guide to determine which version of the overloaded method to actually call.
Thus, overloaded methods must differ in the type and/or number of their
parameters.
While overloaded methods may have different return types, the return type alone is
insufficient to distinguish two versions of a method. When Java encounters a call to an
overloaded method, it simply executes the version of the method whose parameters
match the arguments used in the call.
Let’s have a look-see - - -
Overloading
public class MethodOverloading extends Object
{
public void test(int a) {
System.out.println("a: " + a);
}
public void test(int a, int b) {
System.out.println("a and b: " + a + "," + b);
}
public double test(double a) {
System.out.println("double a: " + a);
return a*a;
}
public static void main(String args[])
{
MethodOverloading MethodOverloading = new MethodOverloading();
double result;
MethodOverloading.test(10);
MethodOverloading.test(10, 20);
result = MethodOverloading.test(5.5);
System.out.println("Result : " + result);
}
}
a: 10
a and b: 10, 20
double a: 5.5
Result: 30.25
Assignment 3: The Maze
The Basic Move Logic:
• Turn Left (or Right)
• While the front is NOT clear
• Turn Right (or Left)
• Move