1. More on Classes & Arrays
Pepper
With help from
and

2. Review - A Class Trace Exercise
What's wrong with the following program?
public class SomethingIsWrong { public static void main(String[] args) { Rectangle myRect; myRect.width = 40; myRect.height = 50; System.out.println ("myRect's area is " + myRect.area()); } }

3. Class Extension
Make sub-classes (put "extends " classname after class)
Can use the entire extended class
Can override methods
This is how we use Fang's game class
Can see all protected and public methods and variables

4. Class Extension - Super
Can choose to execute methods from the super class using super.methodname

5. Dog Class + Special type of Dog
Seeing Eye Dog is a dog
Properties: In addition to being a dog with a name, isAwake and position states, it has a tracking code
Actions: In addition to being able to makeNoise, sleep and wake, it can get its trackingcode and sit to warn for a curb.
Credit to:

6. Dog Class + Special type of Dog
public class Dog { private String name; private Boolean isAwake; private String position; public Dog (String name){ this.name = name; this.isAwake = true; this.position = "standing"; } public String makeNoise(){ return "bark"; } public void sleep(){ this.isAwake = false;} public void wake(){ this.isAwake = true;} public void sit(){ this.position = "sit";} }
public class SeeingEyeDog extends Dog {
private String trackingCode;
public SeeingEyeDog(String name,
String trackingCode){
super(name);
this.trackingCode = trackingCode; }
public String getTrackingCode(){
return this.trackingCode;}
public String sitForCurb(){
super.sit();
super.makeNoise();} }
Credit to:

7. Extended Class Used by Driver
SeeingEyeDog can be placed into Dog or SeeingEyeDog variable type
When in Dog type, it cannot get the tracking code
public class DogDriver {
public static void main(){
Dog pepperPet = new Dog("Olive");
Dog working1 = new SeeingEyeDog("Sarah","ABC");
SeeingEyeDog working2 = new SeeingEyeDog("Coco","ABCD");
System.out.println (pepperPet.makeNoise());
System.out.println (working1.makeNoise());
System.out.println (working2.getTrackingCode());
// System.out.println (working1.getTrackingCode()); wont work
if (working1 instanceof SeeingEyeDog){
SeeingEyeDog temp = (SeeingEyeDog) working1;
System.out.println(temp.getTrackingCode());
}}}

8. Player Extension Make one player Extend to different player types
Example:

9. Extension Limits Can only extend one class
A seeing Eye Dog is a dog, but it is also a trainable being
Use Interface of trainable beings
Both the super and subclass can have objects created.
Animals share methods and properties, but cannot exist without being a specific type of animal such as Dog or Cat.
Use abstract class of Animals

10. Abstract Classes Cannot create its own object
Can contain abstract classes, which every extender must code - compiler complains if the lower class does not implement it.

11. Abstract Class and its extensions
public abstract class Animal{
private String name;
private Boolean isAwake;
public Animal (String name){
this.name = name;
this.isAwake = true; }
public void sleep(){
this.isAwake = false;}
public void wake(){
this.isAwake = true;}
public abstract String eats();
public class Dog extends Animal { private String position; public Dog (String name){ super(name); this.position = "standing"; } public String makeNoise(){ return "bark"; } public void sit(){ this.position = "sit";} public String eats(){ return "Meat and whatever else I find";} }
public class Fish extends Animal {
private boolean isSwimming;
public Fish(String name)
super(name);
this.isSwimming = true; }
public String eats(){
return "little fish and algae";}

12. Animal Driver uses Abstract Class
public class AnimalDriver { public static void main(){ Animal[] myAnimals = new Animal[2]; myAnimals[0] = new SeeingEyeDog("Sarah","ABC"); myAnimals[1] = new Fish ("James"); System.out.println (myAnimals[0].eats()); System.out.println (myAnimals[1].eats()); if (myAnimals[0] instanceof SeeingEyeDog){ SeeingEyeDog temp = (SeeingEyeDog) myAnimals[0]; System.out.println(temp.getTrackingCode()); }

13. Interface
Can create a type that has only abstract methods, with no properties.
Basically a contract to implement interfaces
Contains method headers with no code below it.
Lower classes can implement many interfaces (but only extend one class)
Implementing an interface means you promise (and the compiler checks) that you will implement the methods listed.
For out pets, trainable could be an interface containing the methods sit and stand and stay.

14. Summary - Class Types
Extension: To have all properties and method of super class in the sub class
Add extends <classname> to the subclass
Can override methods inside a subclass
Cannot access anything private in the class
Use super to use superclass methods if overridden
Abstract: To hold common code you want to extend
Cannot be used to create instances
Can insist method names be implemented
Interface: To insist method names be implemented
Cannot have properties
Cannot code methods, only their headers