Review for Exam 1

As you arrive…please get a handout

Today is All Review

1. Inheritance2. General Exam Advice3. HashCode/Equals4. Comparable

Inheritance1. When one class “extends” another, it gets all of the functions (and variables) that

it’s superclass hasclass Superclass {

public int getNum() { return 45; }}class Subclass extends Superclass {

//empty!}

//in some function…Subclass var = new Subclass();//var has a getNum method, even though it’s//got no code! It inherits the method from//Superclass var.getNum();

Because a subclass can do everything a superclass can do, you can use a subclass in any variable that expects a superclass

class Car { public String honk() { return “honk”; } }class ToyotaCamry extends Car { }

public void doHonk(Car carVar} {System.out.println(carVar.honk());

}Car mikesCar = new ToyotaCamry();//a method parameter is just another kind of variabledoHonk(new ToyotaCamry());

But subclasses can add new methods or change the way existing methods work

class Car { public String honk() { return “honk”; } }class ToyotaCamry extends Car {

// we say that ToyotaCamry “overrides” the method honk in carpublic String honk() { return “beep”; }

}

public void doHonk(Car carVar} {System.out.println(carVar.honk());

}Car mikesCar = new ToyotaCamry();Car regularCar = new Car();

//prints beepdoHonk(mikesCar);//prints honkdoHonk(regularCar);

An abstract class is a class that is missing one or more methods

abstract class IntCollection {public abstract add(int new value);

}//abstract classes can never be created//this will not compile!IntCollection collection = new IntCollection();Intcollection.add(7);

The point of abstract classes is to have subclasses that override their abstract

methodsabstract class IntCollection {

public abstract add(int new value); }class IntArrayList extends IntCollection {

public add(int newValue) {myList.add(newValue);

}}//variables of abstract classes can still store//non-abstract subclassesIntCollection collection = new IntArrayList();Intcollection.add(7);

Interfaces are like abstract classes, except they can’t have any non abstract methods

(and you use implements not extends)

interface IntCollection {public abstract add(int new value);

}class IntArrayList implements IntCollection {

public add(int newValue) {myList.add(newValue);

}}

IntCollection collection = new IntArrayList();Intcollection.add(7);

Write the class definitions to match this code

Ninja[] ninjas = new Ninja[2];ninjas[0] = new FireNinja();ninjas[1] = new Ninja();

for(Ninja ninja : ninjas) {ninja.attack();

}//code prints// “You are attacked by a fire ninja”// “You are attacked by a ninja”

//Question:// Could Ninja have an abstract method?// Could Ninja be an interface?// Could this code compile – FireNinja foo = new Ninja();

class Ninja {public void attack() {System.out.println(“You are attacked by a ninja”)}

}

class FireNinja extends Ninja {public void attack() {System.out.println(“You are attacked by a fire ninja”)}

}// Could Ninja have an abstract method? NO!// Could Ninja be an interface? NO!Abstract class and interfaces can not be instantiated

(i.e. you couldn’t say “new Ninja()”)// Could this code compile – FireNinja foo = new Ninja();

NO! – Ninja is the superclass, not the other way around

Today is All Review

1. Inheritance2. General Exam Advice3. HashCode/Equals4. Comparable

What will be on the exam

1. 3 Questions about just solving ordinary APish problems, often with structures like maps, sets, and lists

2. 3 Questions about classes hashcode equals and comparable

3. 1 Question about Big O4. 2 Questions about recursion

Advice

• Don’t forget you get 1 (2-sided) page of notes• Arrive on time, keep track of your time through the exam• When solving coding problems, try to stay as close to genuine

Java as you can• Never leave a question blank – if you can solve 50% of a

problem, that is worth partial credit• A correct non-recursive solution to a problem that requires

recursion is 1/5 points• Don’t forget your base cases for recursion problems! It’s

considered a big miss if it’s not there• Stop immediately when time is called. If you don’t it’s 10% off

your exam grade.

Approximately how I grade coding questions

• 5 points, fully functional algorithm maybe with the occasional missed semicolon or misnamed library call

• 4 points, mostly functional algorithm with an edge case missed

• 3 points, basically the right idea for the algorithm but several missed cases or errors

• 2 points, part of the algorithm done correctly, some other part wrong

• 1 point, some functional code that shows me you understood part of what needed be done, even if you couldn’t do the whole problem

Today is All Review

1. Inheritance2. General Exam Advice3. HashCode/Equals4. Comparable

HashCode and Equals

• All classes inherit from object• All classes have the methods equals and hashCode• But sometimes you want to change them:myMap = new HashMap<ComplexNum, String>();

myMap.put(new ComplexNum(0,0), “ZERO”);// somewhere far away in a different// functionmyMap.get(new ComplexNum(0,0));

What we want

myNum = new ComplexNum(0,0);myNum.equals(new ComplexNum(0,0)) {

//this should be true}How can we make that happen? (Hint rhymes

with “Boveriding”)

The catch

• Equals needs some boilerplate (just look it up if you need it)

• BUT you also must be consistent with hashCode• THE RULES:– If myVar1.equals(myVar2), myVar1.hashCode() must

equal myVar2.hashCode()– To the greatest extent possible, it’s good if myVar1

does not equal myVar2 myVar1.hashCode() does not equal myVar2.hashCode()

Today is All Review

1. Inheritance2. General Exam Advice3. HashCode/Equals4. Comparable

Comparable

• Oftentimes we want to sort our objects• But how do we compare objects to sort them?• Here’s what we want:CheezBurger a = getBurgerA();CheezBurger b = getBurgerB();if(a.isBiggerThan(b)) {//a is bigger than b

}• But in Java, we don’t use “isBiggerThan” we use

“compareTo”

compareTo

• Returns an int• If the int is possitive, bigger• If the int is negative, smaller• If the int is 0, equal sizeCheezBurger a = getBurgerA();CheezBurger b = getBurgerB();if(a.compareTo(b) > 0) {//a is bigger than b

}Note: there are two objects in this comparison, but only 1 parameter

Remember class function’s always have a current instance

class CheezBurger {//more functionsprivate String mySauce;public String getSauce() {

return mySauce;}

}//elsewhereCheezBurger b1 = new CheezBurger(“MAYO”);CheezBurger b2 = new CheezBurger(“Mustard”);

System.out.println(b1.getSauce());

CheezBurger a = getBurgerA();CheezBurger b = getBurgerB();if(a.compareTo(b) > 0) {}

//far away…in class CheezBurgerint compareTo(CheezBurger other) {

//we have two CheezBurgers here//the CheezBurger we’re IN and//The CheezBurger we’re passedreturn mySauce.compareTo(other.mySauce);

}

One final detail

• Classes that have the compare to function should always implement the interface Comparable<ClassName>:

class CheezBurger implements Comparable<CheezeBurger> {

int compareTo(CheezBurger other) {return mySauce.compareTo(other.mySauce);

}

}//elsewhereArrayList<CheezBurger> burgers = getAllBurgers();Collections.sort(burgers); //calls our compareTo

Ok…your turn

Write a new class UtimateCheezBurger. It has two instance variables, a sauce (like the CheezBurger) and a numberOfBurgers. We want to sort UtimateCheezBurger first by sauce, then by numberOfBurgers (increasing).

So Mayo,3 comes before Mayo,6 which comes before Mustard,2

Oh and make sure your class has a constructor so I can initialize the UltimateCheezBurger like this:

UltimateCheezBurger b = new UltimateCheezBurger(“Mayo”,4);

class UltimateCheezBurger implements Comparable<UltimateCheezBurger> {

String mySauce;int myBurgers;

public UltimateCheezBurger(String sauce, int burgers) {

mySauce = sauce;myBurgers = burgers;

}public int compareTo(UltimateCheezBurger other) {

int sauceCompare = mySauce.compareTo(other.mySauce);

if(sauceCompare != 0)return sauceCompare;

return myBurgers – other.myBurgers;}

}