Transcript More on Classes

More on Classes & Arrays
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
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());
}}
 http://docs.oracle.com/javase/tutorial/java/javaOO/Qa
ndE/objects-questions.html
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
This is how we use Fang's game class
Can see all protected and public methods and variables
Class Extension - Super
 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
 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
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
Extend to different player types
Example:
http://home.adelphi.edu/~pe16132/csc171/notes.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.
 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());
}
}
}
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.
 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