Part 2

public static void changeNumber(int[] x) {
    x[0]++;
}
public static void main(String[] args) {
    int[] x = new int[1];
    x[0] = 0;
    changeNumber(x);
    System.out.println(x[0]);
}

What do you think this outputs? What does this actually output?

Part 3

public static void changeNumber(int[] x) {
    x = new int[1];
    x[0] = 1;
}
public static void main(String[] args) {
    int[] x = new int[1];
    x[0] = 0;
    changeNumber(x);
    System.out.println(x[0]);
}

Passing Parameters

• Invoke a method:
  • Evaluate arguments
  • Copy values over to the parameters
• Value of a variable?
  • Value of an int/char: the number / character
  • Value of a String / array / other objects: reference to memory location
• Does this explain what happened in parts 1 - 3?
• Draw memory diagrams for each of these.

Local Variables

• Parameters exist locally
• Cannot be used outside of the method they are defined in

public static void printLines(int num) {
    for (int i = 0; i < num; i++) {
        System.out.println(); // blank line
    }
}
public static void main(String[] args) {
    printLines(20);
    System.out.println(num); // compiler error!
}

Modular Design

• Break up the problem into components: smaller building blocks that can be re-used and/or combined with other components to form an application.
• Implement each component in its own method.
• Test each method on its own.
• Integrate the components together (and test the final solution).

Example: Project 1

What are some “reusable building blocks” we can make for project 1?

• Get input.
• Check if a pair (street, avenue) is a valid position.
• Check if I can get from one position (street / avenue) to another in one move?

If you’re stuck: see if you can try writing these smaller bits first. This might help you get ideas for how to build the larger project.

Methods

Consider the displayTime method:

• What does the method require? These will be its parameters.
• What does the method return? This will be its return type.
  • Multiple ways to design it: could return the string?
  • Or: might not return anything! Instead it might just output!

hourAfter

hourAfter:

• requires the current hour and minute, and the number of minutes to add
• returns the hour of the time after that many minutes.
• Method signature?

int newHour = hourAfter(11, 30, 45);
int newMinute = minuteAfter(11, 30, 45);
// newHour should be 12, new minute should be 15.

Pseudocode for main

int hour = getNumber(...);
int minute = getNumber(...);
int numMins = getNumber(...);
print(current time); // use displayTime!
compute the new hour; // use hourAfter!
compute the new minute; // use minuteAfter!
print("After " + numMins + " minutes, it will be ..."); // use displayTime again!

Group work

• Form a group of 3-5.
• GHC: join a group for Lesson 6
• Everyone in your table should be sure to join the same group.
• Split up the work:
  • Implement each method.
  • Test out each method.
  • Put it all together in the main method.
  • 30 minutes, get as much done as you can.

Input Method

Method getInput:

• Take in the Scanner, a String prompt, a lower bound and an upper bound as parameters.
• Display the prompt to the user.
• If the user types in something that’s not an integer, output “That is not an integer”, and exit.
• If they type in an integer that is not between the low and high variables, output that the number is not between low and high, and exit.
• Otherwise, return the number the user inputted in.

Method skeleton

public static int getInput(Scanner sc, String prompt, int low, int high) {


}

Loop

• Use a while loop:
  • As long as you aren’t at the right place, go somewhere.
  • What’s the loop condition?
    • currentRow != endRow && currentCol != endCol?
    • currentRow != endRow || currentCol != endCol?
    • Which one works? How do you know? (Test cases?)

Where to move?

• Many possible strategies.
• Maybe go anywhere that’s valid?
• Maybe try to go in the right “direction”?

Suggestion

• First, check if you can get there in one move.
  • How?
• If you can, go straight there.
• Otherwise?
• Come up with examples on paper, draw it out, find a strategy.

Grading

Keep in mind the grading rubric:

• 15%: compiles.
• 20%: style. Good variables names! Indent your code properly. Comments that explain why you do what you are doing.
• 15%: does not crash on any input.
• 10%: written explanation of what you did (how did you solve the problem? Big picture explanation)
• 40%: How many of the test cases do you pass / optimize?

Exam 1

• Reminder: Exam 1 is next Thursday!!!
• We will review on Monday.
• One page of notes will be allowed.