Download Lecture 10 PowerPoint

Lecture 10
Instructor: Craig Duckett
Assignment 1 Revision
DUE TONIGHT, April 26th,
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! I want everyone in this class to be successful!
Assignment Dates (By Due Date)
• Assignment 1 Revision (LECTURE 10)
TONIGHT Wednesday, April 26th
• Assignment 2 Revision (LECTURE 12)
•
•
•
•
The Fickle
Finger of Fate
Wednesday, May 3rd
Assignment 3 (LECTURE 13)
Monday, May 8th
Assignment 3 Revision (LECTURE 16)
Wednesday, May 17th
Assignment 4 (LECTURE 19)
Wednesday, May 31st
Assignment 4 Revision(LECTURE 20)
Monday, June 5th
3
But First…
The Quiz!
Mid-Term Post-Mortem
Best Class Ever! Class Average is 139/150!
TODAY BEGINS THE SECOND HALF OF THE BIT115 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!
Parameters
Arguments
Method Overloading
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:
method overloading
• You should have enough coding behind you by the end of the lecture
MONDAY to successfully complete the coding for Assignment 3 “The
Maze”:
• Successfully Navigate through the Maze from start to finish using
various logic
• After Monday’s lecture, 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, a method like moveMultiple() should
move the robot through multiple intersections
Things happening in 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…
Let’s look at how this works using the Robot and RobotSE classes, before we walkthrough how to use arguments and parameters with our own methods.
http://www.learningwithrobots.com/doc/
simple_argument.java - scanner_argument_with_RobotSE_class.java - scanner_argument_with_Robot_class.java
Arguments and Parameters
A method in new class up top:
PARAMETER
moves
Now in the
programming world
the language tends
to get a little loose,
so these words are
often interchanged
since both things
are dealing with
values being
passed into and out
of parentheses.
counter
PASS
public void moveMultiple(int moves)
{
int counter = 0;
while(counter < moves)
{
move();
counter++;
}
}
Google
In main below:
Scanner keyboard = new Scanner(System.in);
int howFar = keyboard.nextInt();
rob.moveMultiple(howFar);
ARGUMENT
No need to fear! We will look at this in step-by-step detail in a moment 
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);
Or in main you’d call it this way:
this.moveToAvenue(destAve);
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);
EXAMPLES: Step-by-Step
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 parameter
{
int counter = 0;
while( counter < numberOfIntersections) // replace 5 with the passed 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
{
int numMoves = keyboard.nextInt();
System.out.println ("You entered a "
rob.moveMultiple(numMoves);
}
checks the input is an integer
// nextInt puts it into memory container
+ numMoves + "."); // called numMoves
LET’S HAVE A CLOSER LOOK  simple_scanner_argument.java
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 + ".");
rob.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 + ".");
rob.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 + ".");
rob.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 + ".");
rob.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 + ".");
rob.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
Read the Directions !
You can work on Assignment 3 alone
(one person)
-orYou can work on Assignment 3 with a partner
(two people)
-orYou can work on Assignment 3 as a team of three
(three people)
ONLY ONE PERSON HAS TO SUBMIT, BUT MAKE
SURE EVERYONE’S NAMES ARE ON ALL THE FILES
Assignment 3: The Maze
HINT #1:
The Basic Move Logic:
• Turn Left (or Right)
• While the front is NOT clear
• Turn Right (or Left)
• Move
A NOTE ABOUT THE ICE NUMBERS GOING FORWARD:
Today is Lecture 10, but the ICE number is ICE 11. This is because some
quarters have a different number of lectures than Spring quarter, so I
include a buffer/study day right before the Mid-Term much like the
Buffer/Study day this quarter right before the Final Exam.
Thus, going forward, all the ICE numbers will be “off-by-one” when
compared to the Lecture number.