Transcript Inheritance

Inheritance, Abstract &
Interface
Pepper
With help from
http://docs.oracle.com/javase/tutorial/java/IandI/super.html
and
http://www.cis.upenn.edu/~palsetia/java/Animal/index.shtm
l
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: http://www.cis.upenn.edu/~palsetia/java/Animal/index.shtml
Class Extension
Make sub-classes (put "extends " classname after class)
http://home.adelphi.edu/~pe16132/csc171/notes/fangstuf
f/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.methodname
 http://docs.oracle.com/javase/tutorial/java/IandI/super
.html
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 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 void sleep(){
this.isAwake = false;}
public void wake(){
this.isAwake = true;}
public void sit(){
this.position = "sit";}
}
public String sitForCurb(){
super.sit();
super.makeNoise();}
}
Credit to: http://www.cis.upenn.edu/~palsetia/java/Animal/index.shtml
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());
}}}
Player Extension
 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/presentation
s.html
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.
 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
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.
 http://docs.oracle.com/j
avase/tutorial/java/Iand
I/abstract.html
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 class Fish extends Animal
{
private boolean isSwimming;
public String makeNoise(){
return "bark"; }
public Fish(String name)
{
super(name);
this.isSwimming = true;
}
public void sit(){
this.position = "sit";}
public String eats(){
return "little fish and algae";}
}
public String eats(){
return "Meat and whatever
else I find";}
}
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());
}
}
}
Interfaces
 More limits
 Cannot extend two classes
 Trainable
 Animal
 Interface
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 our pets, trainable could be an interface containing
the methods sit and stand and stay.
 http://docs.oracle.com/javase/tutorial/java/IandI/interfac
eDef.html
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 be used to create instances
 Cannot have properties
 Cannot code methods, only their headers