25
Abstract Classes • We often define classes as subclasses of other classes – First, define the superclass – In some cases, a superclass may not have enough specificity to allow for an implementation of one or more methods • a GeometricObject class might be the parent for Circle and Rectangle • computeArea and computePerimeter are two useful methods for these subclasses but GeometricObject is too generic of a class to be able to implement these methods on • yet we want to define these methods in GeometricObject so they are inherited by Circle and Rectangle • recall we did something similar when implement Vehicle so that other Vehicle subclasses could inherit getBattleUtility • An abstract method is a definition for a method without an implementation • An abstract class is a class that contains at least one abstract method

Abstract Classes We often define classes as subclasses of other classes – First, define the superclass – In some cases, a superclass may not have enough

Embed Size (px)

Citation preview

Page 1: Abstract Classes We often define classes as subclasses of other classes – First, define the superclass – In some cases, a superclass may not have enough

Abstract Classes• We often define classes as subclasses of other classes– First, define the superclass – In some cases, a superclass may not have enough specificity to

allow for an implementation of one or more methods• a GeometricObject class might be the parent for Circle and Rectangle• computeArea and computePerimeter are two useful methods for these

subclasses but GeometricObject is too generic of a class to be able to implement these methods on

• yet we want to define these methods in GeometricObject so they are inherited by Circle and Rectangle

• recall we did something similar when implement Vehicle so that other Vehicle subclasses could inherit getBattleUtility

• An abstract method is a definition for a method without an implementation

• An abstract class is a class that contains at least one abstract method

Page 2: Abstract Classes We often define classes as subclasses of other classes – First, define the superclass – In some cases, a superclass may not have enough

Abstract Classes• You cannot instantiate an object of an abstract class

(although you can declare a variable to be of that type for polymorphism)– Here we see obj is a GeometricObject– We cannot instantiate obj to be a GeometricObject but we can

instantiate it to be a Circle or a Rectangle• GeometricObject obj;• obj = new Circle(10);• …• obj = new Rectangle(5,10);

• The reason for having abstract classes is first to provide a “placeholder” that informs programmers of what needs to be implemented in a subclass and second to provide a common basis for all subclasses of this superclass

Page 3: Abstract Classes We often define classes as subclasses of other classes – First, define the superclass – In some cases, a superclass may not have enough

Defining an Abstract Class• Add the word abstract to the class header

– public abstract class Name

• You can define instance data, constants and methods as normal– You can also implement at least one abstract method (you do not

have to have abstract methods in an abstract class)

• To declare an abstract method– Place the word abstract in the method header– In place of the method’s implementation {…} just put a ;

• public abstract void foo(…);

– The method’s profile (return type, parameters) must be exactly as you expect subclasses to implement them• you must override an abstract method, it can not be overloaded• you cannot make an abstract method static

• The example that follows is the UML for GeometricObject, Circle and Rectangle

Page 4: Abstract Classes We often define classes as subclasses of other classes – First, define the superclass – In some cases, a superclass may not have enough

GeometricObject -color: String

-filled: boolean

-dateCreated: java.util.Date

#GeometricObject()

#GeometricObject(color: string, filled: boolean)

+getColor(): String

+setColor(color: String): void

+isFilled(): boolean

+setFilled(filled: boolean): void

+getDateCreated(): java.util.Date

+toString(): String

+getArea(): double

+getPerimeter(): double

Circle

-radius: double

+Circle()

+Circle(radius: double)

+Circle(radius: double, color: string, filled: boolean)

+getRadius(): double

+setRadius(radius: double): void

+getDiameter(): double

Rectangle -width: double

-height: double

+Rectangle()

+Rectangle(width: double, height: double)

+Rectangle(width: double, height: double, color: string, filled: boolean)

+getWidth(): double

+setWidth(width: double): void

+getHeight(): double

+setHeight(height: double): void

The # sign indicates protected modifier

Abstract class

Abstract methods are italicized

Methods getArea and getPerimeter are overridden in Circle and Rectangle. Superclass methods are generally omitted in the UML diagram for subclasses.

Page 5: Abstract Classes We often define classes as subclasses of other classes – First, define the superclass – In some cases, a superclass may not have enough

Some Comments• Abstract methods cannot be placed in non-abstract classes

– If a class extends an abstract class, it must either implement all inherited abstract methods or itself also be abstract

– Recall that you cannot instantiate an object of an abstract class

• An abstract class does not need to contain abstract methods– You would only do this if the superclass was merely a base for

other classes to inherit from

• A subclass can override a parent class’ method and make it abstract – in which case the subclass would have to be abstract– Here the superclass is not [necessarily] abstract while the

subclass is– This is unusual but allows you to “shut off” inheritance of a

superclass implementation of a method

Page 6: Abstract Classes We often define classes as subclasses of other classes – First, define the superclass – In some cases, a superclass may not have enough

Example: Revising Vehiclepublic abstract class Vehicle{

protected String type;protected boolean heavilyArmored;protected int capacity;protected int speed;protected int armament;

public Vehicle(String t) { ... }public String getType() {...}public boolean getHeavilyArmored() {...}public int getCapcity() {...}public int getSpeed() {...}public int getArmament() {...}public String toString() {...}public abstract int getBattleUtility

(boolean night, boolean roughTerrain, boolean needGroundSupport, boolean needHeavyArms, boolean antiAircraftGuns, boolean equipment, int distance);

}

As before

abstract and no implementation

Page 7: Abstract Classes We often define classes as subclasses of other classes – First, define the superclass – In some cases, a superclass may not have enough

Another Example• We want to define a deck of cards

– There are different types of cards• Ordinary cards which are shuffled randomly• Magic cards which are not shuffled randomly• Stacked decks

• We will define CardClass to represent an abstract deck of cards– This class will create instance data of the deck itself (an array of ints

which indicate the order of the cards currently) and whether a particular card has been dealt yet (a boolean array)

– Non-abstract methods will be a constructor and accessors to get a card and determine if a card has been dealt

– But the shuffle method will be abstract based on the subclass

• We will then implement a subclass, PlayingCards to be a deck of ordinary playing cards– The shuffle method is implemented as a simple random generation

of the sequence of cards (numbers 0-51)

Page 8: Abstract Classes We often define classes as subclasses of other classes – First, define the superclass – In some cases, a superclass may not have enough

public abstract class CardClass {protected int[] deck;protected boolean[] dealt;public CardClass() {

deck=new int[52];dealt=new boolean[52];for(int i=0;i<52;i++) dealt[i]=false;

}public boolean dealtYet(int index) throws

IndexOutOfBoundsException {if(index<52) return dealt[index];else throw new IndexOutOfBoundsException(index +

" is too large for the size of this deck");}public int getCard(int index) throws

IndexOutOfBoundsException {if(index<52) return deck[index];else throw new IndexOutOfBoundsException(index +

" is too large for the size of this deck");}public abstract void shuffle();

}

Page 9: Abstract Classes We often define classes as subclasses of other classes – First, define the superclass – In some cases, a superclass may not have enough

import java.util.*;

public class PlayingCards extends CardClass {protected Random g;public PlayingCards() {

super();g=new Random();

}

public void shuffle() {boolean[] order=new boolean[52];int i, temp;for(i=0;i<52;i++) order[i]=false;for(i=0;i<52;i++) {

do{

temp=g.nextInt(52);}while(order[temp]);order[temp]=true;deck[i]=temp;

}}

}

Page 10: Abstract Classes We often define classes as subclasses of other classes – First, define the superclass – In some cases, a superclass may not have enough

Arrays of an Abstract Class• You cannot instantiate an abstract class• But you can create an array of an abstract class and

instantiate the individual array elements to be subclasses– Assume we have our previously described

GeometricShape, Circle and Rectangle classes– GeometricShape[ ] shapes = new GeometricShape[10];• This is legal

– shapes[0] = new Circle(10);– shapes[1] = new Rectangle(5, 10);

• These are legal

– Shapes[2] = new GeometricShape( );• This is illegal because GeometricShape is abstract

Page 11: Abstract Classes We often define classes as subclasses of other classes – First, define the superclass – In some cases, a superclass may not have enough

Interfaces• Java does not permit multiple inheritance (inheriting

from multiple classes) but it does provide interfaces– In a way, interfaces are a form of multiple inheritance

• An interface is like an abstract class in that it defines a portion of a class but does not implement it– The interface class contains constants and abstract methods

only, no implemented methods and no instance data– By implementing an interface, like extending an abstract

class, you are completing the class– The advantage of implementing an interface is that you are

stating that the given class will act a certain way so that other classes can expect a particular functionality• for instance, you might implement Comparable indicating that

the class will implement comparesTo

Page 12: Abstract Classes We often define classes as subclasses of other classes – First, define the superclass – In some cases, a superclass may not have enough

Implementing an Interface• You add to the class header implements InterfaceName

• Now you must override the abstract method(s) defined in the Interface– If you do not override all of the abstract methods, you will receive

compilation errors– You cannot instantiate an object of a type of Interface class because

of the abstract methods (just as you cannot instantiate the object of an abstract class), all you can do is implement the Interface class in your own class

• One of the most significant types of Interfaces is the class of GUI handlers that will respond when a GUI component, mouse, or keyboard action occurs– We will look at this later in the semester– Here, we will concentrate on two of the most significant interfaces:

Comparable and Cloneable

Page 13: Abstract Classes We often define classes as subclasses of other classes – First, define the superclass – In some cases, a superclass may not have enough

Implementing Comparable• Comparable is an interface class meaning that as a class, it is

defined as an interface which means that you cannot instantiate an object of this type

• You also will (most likely) not extend Comparable but instead implement Comparable

• The reason for the Comparable interface is to indicate that a class that you are implementing will have the ability to directly compare two instances of this type– recall that the relational operators (<, >, etc) are not available for

objects, only for primitive types– so instead, we will implement Comparable which requires that we

implement a method called compareTo (recall Strings have this method, the reason being that Strings implement Comparable requiring this method be implemented)

• How do you compare two objects? Depends on the type of object – we look at a couple of examples coming up

Page 14: Abstract Classes We often define classes as subclasses of other classes – First, define the superclass – In some cases, a superclass may not have enough

Continued• To implement Comparable, do the following– Add implements Comparable to the class header

• As in public class MyClass extends YourClass implements Comparable

– Add a compareTo method with the following profile• public int compareTo(Object o) {…}• Notice that your compareTo is receiving an Object, not a

MyClass object, why? Because this is how compareTo appears as an abstract method in the Comparable class

• If you do not match this profile exactly then you are not overriding the abstract compareTo but instead overloading it, and so compilation will fail

• compareTo will return an int value: negative if this object is less than the object passed to compareTo, positive if this object is greater and 0 if the two objects are deemed equivalent

Page 15: Abstract Classes We often define classes as subclasses of other classes – First, define the superclass – In some cases, a superclass may not have enough

Examples• Here, we make the Circle class (introduced earlier in

the semester) Comparable– Circles will be compared based on their radius

• As an alternative to using (Object o) and downcasting as shown above, we can implement Comparable<Circle> employing generics– see the next example

public class Circle extends GeometricObject implements Comparable {... // as before

public int compareTo(Object o) { if(radius>((Circle)o).getRadius( )) return 1; else if(radius<((Circle)o).getRadius( )) return -1; else return 0;}

}

Page 16: Abstract Classes We often define classes as subclasses of other classes – First, define the superclass – In some cases, a superclass may not have enough

Another Example: Comparing Namespublic class Name implements Comparable<Name> {

private String first, middle, last;

public Name(String f, String m, String l) { first=f;middle=m;last=l;}

public String getFirst() {return first;}public String getMiddle() {return middle;}public String getLast() {return last;}

public int compareTo(Name n) { if(last.compareTo(n.getLast())>0) return 1; else if(last.compareTo(n.getLast())<0) return -1; else if(first.compareTo(n.getFirst())>0) return 1; else if(first.compareTo(n.getFirst())<0) return -1; else if(middle.compareTo(n.getMiddle())>0) return 1; else if(middle.compareTo(n.getMiddle())<0) return -1; else return 0;}

}

Page 17: Abstract Classes We often define classes as subclasses of other classes – First, define the superclass – In some cases, a superclass may not have enough

Creating An Interface Class• You can create your own interface classes by substituting

the modifier interface in place of class– public interface InterfaceName

• The Interface’s definition will consist solely of constants and abstract method definitions– The abstract methods have no body (no {…}) and end with a ;

• Example: we have a class called Instrument to define various types of musical instruments– We want to define an interface class called Playable which, if

implemented, will indicate how to play that instrument– public interface Playable { public abstract String howToPlay( ); }

– Now, if we implement Playable, we have to define a howToPlay method which returns a String

Page 18: Abstract Classes We often define classes as subclasses of other classes – First, define the superclass – In some cases, a superclass may not have enough

Implementing Playablepublic class Drums extends Instrument implements Playable { private int numDrums; public Drums(int size) { super(“Drums”); // assume Instrument’s constructor assigns numDrums=size; // the var type to this String } public Drums( ) { super(“Drums”); numDrums=0; } public String howToPlay( ) { return “Strike drums with drumsticks or mallets”; }}

public class Guitar extends Instrument implements Playable { private int numStrings; // constructors similar to Drums public String howToPlay( ) { return “Strum strings with pick or fingers”; }}

Page 19: Abstract Classes We often define classes as subclasses of other classes – First, define the superclass – In some cases, a superclass may not have enough

Implementing Cloneable• Consider the following code

– SomeObject o1, o2;– o1=new SomeObject(…);– o2=o1;

• In this code, o1 points at an object in heap memory that has been instantiated with the new operator, but what about o2?– Is o2 another object with the same values as o1 or is it the same object?

It is the same

• If we instead want to “clone” o1 into o2 we would create another object, have o2 point at the new object in the heap, and set all of its values to be the same as o1

• In this way, we have two different objects which are equivalent rather than two reference variables which are equal in that they are pointing at the same object

• We accomplish this by implementing Cloneable which requires implementing a clone method

Page 20: Abstract Classes We often define classes as subclasses of other classes – First, define the superclass – In some cases, a superclass may not have enough

Cloneable Interface• Unlike Comparable, the Cloneable interface is empty –

there is no abstract method defined– You must still implement the clone method

• According to the textbook, the abstract method for clone is defined as follows– protected native Object clone( ) throws CloneNotSupportedException;

– native means that the actual implementation for copying data is left up to the JVM, not the compiler

– Notice that clone returns an Object so you will have to cast the returned object appropriately

– You must either add the “throws Clone…” to your method header or handle it in a try-catch block when you attempt to clone an object of the class you have implemented as cloneable

Page 21: Abstract Classes We often define classes as subclasses of other classes – First, define the superclass – In some cases, a superclass may not have enough

Example: Person Classpublic class Person implements Cloneable{ private String name; private int age, height, weight; private boolean isMarried; private Person spouse;

public Person() { age=0; name="unknown"; isMarried=false; spouse=null; }

public Person(String n, int a, int h, int w) { age=a; name=n; height=h; weight=w; isMarried=false; spouse=null;}

Page 22: Abstract Classes We often define classes as subclasses of other classes – First, define the superclass – In some cases, a superclass may not have enough

public Person(String n, int a, int h, int w, Person s) { age=a; name=n; height=h; weight=w; isMarried=true; spouse=s;}

public void getsMarried(Person s) { if(!isMarried) {

isMarried=true; spouse=s;

} else System.out.println(name + " cannot marry " + s.getName() + " until " + name + " gets a divorce!");}

public String getName() {return name;}public int getAge() {return age;}public int getHeight() {return height;}public int getWeight() {return weight;}public String getSpouseName() {if(isMarried)

return spouse.getName(); else return "not married";}

Page 23: Abstract Classes We often define classes as subclasses of other classes – First, define the superclass – In some cases, a superclass may not have enough

public void setName(String n) { if(name==null) name=n;}public void setAge(int a) { if(age==0) age=a;}public void setHeight(int h) { if(height==0) height=h;}public void setWeight(int w) { if(weight==0) weight=w;}public void setMarried(Person s) {

if(!isMarried) {

isMarried=true;spouse=s;

}}

public Object clone() throws CloneNotSupportedException{ Person p=(Person)super.clone(); p.setName(name); p.setAge(age); p.setHeight(height); p.setWeight(weight); p.setMarried(spouse); return p;}

} // ends the class

Page 24: Abstract Classes We often define classes as subclasses of other classes – First, define the superclass – In some cases, a superclass may not have enough

People Classpublic class People{

public static void main(String[] args) throws CloneNotSupportedException

{Person p1=new Person();Person p2=new Person("Frank Zappa", 53, 69, 158);Person p3=new Person("Gail Sloatman", 50, 63, 110);p2.getsMarried(p3);p3.getsMarried(p2);p1=(Person)p2.clone();System.out.println(p1.getName() + " " + p1.getAge() + " " + p1.getHeight() + " " + p1.getWeight() + " " + p1.getSpouseName());

}}

An alternative implementation is to remove the throws statement from main and insert the p1=(Person)p2.clone(); statement in a try block with a catch block that can catch CloneNotSupportedException

Page 25: Abstract Classes We often define classes as subclasses of other classes – First, define the superclass – In some cases, a superclass may not have enough

Interfaces vs Abstract Classes• Both types provide a basis for the programmer to build upon

– Abstract classes support single inheritance– Interfaces offer a form of multiple inheritance– Abstract classes can contain instance data and non-abstract methods– Interfaces cannot contain instance data and non-abstract methods (and

can even be empty), the only variables must be constants (public static final) and the only methods must be public abstract

– Abstract classes can have constructors, interfaces will not– Objects of either type can be declared but not instantiated

• An interface class can itself extend other interfaces in which case implementing that interface requires implementing all of the methods of that interface and its superclasses– A naming convention: class names are usually nouns but interface

names can be nouns or adjectives (particularly if they end with “able” or “ible” such as “Comparable” or “Cloneable”)