GaussianInteger

public GaussianInteger multiply(GaussianInteger other) {
  return ...
}

• Don’t pass around two integer variables.
• If you need a GaussianInteger, use the new data type you created!

Project 2

// Library class:
public void addBook(String title, String author, int year) {
  // Is this object-oriented?
}

• Same idea: adding a “book” should mean adding a Book.
  • Don’t pass around the title / author / year, just the Book object.
  • How do you get the title / author / year from the Book object?
  • Define new getters!

findByTitle

• Return type / parameters?
• For \(i = 0\) to the length of the list:
  • If the title of book \(i\) equals the title that you’re looking for, print it out
  • Can assume there is only one book with that title, so you can return at this point.
• If you don’t find a book by that title, output “There are no books called … in this library.”
  • How can you tell if there is no book with that title?

findByAuthor

• Return type / parameters?
• For \(i = 0\) to the length of the list:
  • If the author of book \(i\) equals the author that you’re looking for, print it out
  • In this case, there may be more than one book by the same author.
• If you don’t find a book by that author, output “There are no books authored by … in this library.”
  • How can you tell if there is no book with that title?
  • A little harder than the previous one!

Problem

What’s wrong with this?

for (int i = 0; i < bookList.size(); i++) {
  if (bookList.get(i).getAuthor().equals(author)) {
    System.out.println(i + ". " + bookList.get(i));
  } else {
    System.out.println("There are no books written by " + author);
  }
}

Solution?

Hint

• Keep a boolean variable that checks if anyone is above that grade.
• How would this help?
• How do you use it?

Progress

• Book class (done?)
• Library class (finish this week?)
• Main class: while loop
  • Output menu of choices (add book, list all books, etc)
  • Get the user’s choice (1 - 5, or a - e if you prefer)
  • Take the appropriate action (using the Library object?)
  • Exit if the user inputs in choice 5 (quit).

Pseudocode

public static void main(String[] args) {
    while (something) {
        printMenu()
        getChoice()
        if (choice == 1) {
            addBook()
        } else if (choice == 2) {
            listAllBooks()
        } else if...
    }
}

Scanner issue

public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    System.out.println("Enter in a number: ");
    int x = sc.nextInt();
    System.out.println("Enter in a name: ");
    String name = sc.nextLine();
    System.out.println("You entered: " + x + ", " + name);
}

• What happens when we run this? Fix from Chapter 3.
• Will probably run into this when you add a Book
  • author (String), title (String), year (int?).
  • Make sure after every nextInt in your code, you handle this problem.

Rules of thumb

• “Checked” vs “unchecked” exceptions: checked can be recovered from, unchecked are “logic errors”
• Exceptions are for exceptional situations, not as fancy if-thens!

Polymorphism

• IOException needs to be “caught”, but IllegalStateException doesn’t.
• How does the compiler know?
• IOException extends from Exception; IllegalStateException extends from RuntimeException!

Example

public void sort(List<Integer> list) {
    // don't care how the list is implemented
    // just that I have a list of integers
}

public static void main(String[] args) {
    List<Integer> list1 = new LinkedList<Integer>();
    List<Integer> list2 = new ArrayList<Integer>();
    sort(list1);
    sort(list2);
}

Different Implementations

ArrayList and LinkedList are two different implementations of the same List interface.

• Both of them implement add, get, and size.
• ArrayList: keeps an array, resizes that array when needed.
• LinkedList: keeps each item in a “node”, node has a “link” to the next node.
  • add: create a new node, link from the last node.

Implementation Details

• The differences between an ArrayList and LinkedList are internal.
• Externally: we can call list.get(10); or list.add("hello"); on either one.
• Those differences are called “implementation details”

When we write a method, if we don’t care how list is implemented, we can just ask for a List as a parameter.

Implementing Comparable

In order to implement the interface in your class:

public class MyClass implements Comparable<MyClass> {

    // instance variables, constructors, and other methods

    public int compareTo(MyClass other) {
        // return a positive number if this > other
        // return 0 if this == other
       // return a negative number if this < other
    }
}

Exercise

Starter code Implement the “compareTo” method in the Location class. Implement it so that:

• A Location on a lower street (south) is “less” than a Location with a higher row
• If two Locations are on the same street, a Location on a lower avenue (to the east) is “less” than a Location with a higher avenue

Output

Run the main method after you have implemented compareTo. It should output:

[10 St and 7 Ave, 15 St and 2 Ave, 15 St and 5 Ave, 25 St and 3 Ave]

Introducing Polymorphism

Two primary ways of introducing polymorphism in Java:

• Implementing interfaces
• Extending classes (inheritance).

Dynamic Binding

When an object is instantiated, it has a “compile-time” (declared) type and a “run-time type” (the type of the actual object that is instantiated).

int width = 5; int height = 5;
Rectangle r = new Rectangle(width, height);
Square s = new Square(width);
Rectangle r2 = new Square(width);

What are the declared and run-time types of \(r\), \(s\), and \(r2\)?

Exercise

LinkedList<String> linkedList = new LinkedList<>();
ArrayList<String> arrayList = new ArrayList<>();
List<String> abstractList;

Which of the following assignments are legal?

1. abstractList = linkedList;
2. abstractList = arrayList;
3. arrayList = abstractList;
4. arrayList = linkedList;
5. linkedList = arrayList;
6. linkedList = abstractList;

Think about

List<String> list = new ArrayList<>();
list.add(5);

• What does the compile-time type tell you about the “add” method?
• What does the run-time type tell you about the “add” method?