Inheritance, Abstract & Interface
Pepper
With help from http://
docs.oracle.com/javase/tutorial/java/IandI/super.html
andhttp://www.cis.upenn.edu/~palsetia/java/Animal/index.shtml
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.
Dog Class + Special type of Dog
Credit to: http://www.cis.upenn.edu/~palsetia/java/Animal/index.shtml
Make sub-classes (put "extends " classname after class)http://home.adelphi.edu/~pe16132/csc171/notes/fangstuff/Wackadot.java
Can use the entire extended class Can override methods Can see all protected and public methods and variables Can choose to execute methods from the super class
using super.methodnamehttp://docs.oracle.com/javase/tutorial/java/IandI/super.html
Class Extension
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";}}
Dog Class + Special type of Dog
Credit to: http://www.cis.upenn.edu/~palsetia/java/Animal/index.shtml
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();}}
SeeingEyeDog can be placed into Dog or SeeingEyeDog variable type When in Dog type, it cannot get the tracking codepublic 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()); }}}
Extended Class Used by Driver
Make one player Constructor – starts on square 1 and has a name Roll dice Say he is joining the game
Extend to different player types Zorgon - some number of eyes as well Override a method: He has a different message
to say he is joining the game. He tells of his powers
Extra method: ability to jump ahead the same number of squares as eyes.
Example: http://home.adelphi.edu/~pe16132/csc171/
presentations.html
Player Extension
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. Problem: 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
Extension Limits
Cannot create its own object
Can contain abstract classes, which every extender must code - compiler complains if the lower class does not implement it.
http://docs.oracle.com/javase/tutorial/java/IandI/abstract.html
Abstract Classes
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";}}
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 Fish extends Animal{ private boolean isSwimming;
public Fish(String name) { super(name); this.isSwimming = true; }
public String eats(){ return "little fish and algae";}}
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()); } }}
Animal Driver uses Abstract Class
More limits Cannot extend two classes
Trainable Animal
Interface
Interfaces
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 our pets, trainable could be an interface containing the methods sit and stand and stay.
http://docs.oracle.com/javase/tutorial/java/IandI/interfaceDef.html
Interface
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 be used to create instances Cannot have properties Cannot code methods, only their headers
Summary - Class Types