comp1004: object oriented design i

Comp1004: Object Oriented Design IAbstract Classes and Interfaces

Coming up

• Abstract Classes and Methods

• The Challenges of Object Oriented Design– Pets vs. Animals

• Multiple Inheritance vs. Interfaces

Abstract Classes and Methods

Designing for PolymorphismArrayList<Broker> brokers;Brokers = new ArrayList<Broker>();

brokers.add(new Broker(“pm@numberten.gov.uk”));brokers.add(new Broker(“pres@france.gov.fr”));brokers.add(new SMSBroker(“07123 456789”));brokers.add(new SnailBroker(“1600 Penns Ave.

D.C.”));brokers.add(new SMSBroker(“07987 654321”));

String message = “Reminder. Fix economy!”);

for(Broker b : brokers) {b.sendMsg(message);

}

Broker

email

sendMsg

SMSBroker

number

sendMsg

SnailBroker

address

sendMsg

Designing for PolymorphismBroker

email

sendMsg

SMSBroker

number

sendMsg

SnailBroker

address

sendMsg

A design that takes advantage of Polymorphism – but there is something odd going on. Think about the constructors…

Designing for PolymorphismBroker

email

sendMsg

SMSBroker

number

sendMsg

SnailBroker

address

sendMsg

A design that takes advantage of Polymorphism – but there is something odd going on. Think about the constructors…

public class Broker {String email;//code omittted

public Broker(String emailaddr) {email = emailaddr;}

}

public class SMSBroker extends Broker {String number;//code omittted

public SMSBroker(String phoneno) {super(“Doesn’t matter – this is not used”);number = phoneno;}

}

Designing for PolymorphismBroker

sendMsg

SMSBroker

number

sendMsg

SnailBroker

address

sendMsg

A better design would be to have a neutral Broker, and make EmailBroker another sub-class…

EmailBroker

email

sendMsg

Now there is no redundant data in the sub-classes

Designing for PolymorphismBroker

sendMsg

SMSBroker

number

sendMsg

SnailBroker

address

sendMsg

A better design would be to have a neutral Broker, and make EmailBroker another sub-class…

EmailBroker

email

sendMsg

Now there is no redundant data in the sub-classes

But what does this method do?

It has to be here for Polymorphism to work.

But in fact does it make sense to have an instance of a Broker at all?

Abstract Classespublic abstract class Broker {

public void sendMsg(String msg) {//exists so it can be//overriden in a subclass}

}

public class SMSBroker extends Broker {String number;//code omittted

public void sendMsg(String msg) {//some code to send the//msg to the phoneno}

}

Abstract classes cannot be instantiated (i.e. created using the new keyword)

They exist only to be extended

A non-abstract class (the ones we normally deal with) are called concrete classes

Abstract ClassesAbstract classes cannot be instantiated (i.e. created using the new keyword)

They exist only to be extended

A non-abstract class (the ones we normally deal with) are called concrete classes

But this is still ugly – there is no guarantee that sub-classes will override this empty method!

public abstract class Broker {

public void sendMsg(String msg) {//exists so it can be//overriden in a subclass}

}

public class SMSBroker extends Broker {String number;//code omittted

public void sendMsg(String msg) {//some code to send the//msg to the phoneno}

}

Abstract Methodspublic abstract class Broker {

public abstract void sendMsg(String msg);

}

public class SMSBroker extends Broker {String number;//code omittted

public void sendMsg(String msg) {//some code to send the//msg to the phoneno

}}

Abstract classes cannot be instantiated (i.e. created using the new keyword)

They exist only to be extended

A non-abstract class (the ones we normally deal with) are called concrete classes

So we can declare sendMsg as an abstract method – this means all concrete sub-classes must override it

The point

• By putting abstract methods into your superclasses, you’ve guaranteed that the concrete subclasses will provide them

• This enables you to code for polymorphism without having to write methods that contain no code or will never be called

Abstract Summary• An abstract class is a class that is declared abstract—it may or may not include abstract

methods. Abstract classes cannot be instantiated, but they can be subclassed.

• An abstract method is a method that is declared without an implementation (without braces, and followed by a semicolon), like this:

abstract void sendMsg(String msg);

• If a class includes abstract methods, the class itself must be declared abstract, as in:

public abstract class Broker {// declare fields// declare non-abstract methodsabstract void sendMsg(String msg);

}

• When an abstract class is subclassed, the subclass usually provides implementations for all of the abstract methods in its parent class. However, if it does not, the subclass must also be declared abstract.

The Challenges of Object-Oriented Design

Back to an Animal Hierarchy

Animal

Canine

Dog Wolf

Feline

Cat Tiger

Rodent

Hamster

We included methods for sleep, roam and eat in Animal

In some subclasses these were overridden

Re-using this code

• What if we wanted to reuse this code to model someone’s pets?

• We want to implement some new stroke() methods, feedTreat() methods and some play() methods.

• How should we do this?

• In groups of no more than four…

• Come up with some places in the hierarchy that we could add those methods to the appropriate animals. Think about using abstract methods in some cases

• Come up with the good points and the drawbacks for each location

Animal

Canine

Dog Wolf

Feline

Cat Tiger

Rodent

Hamster

Add methods for stroke, feedTreat and play

• Where could the play() method go?

Animal

Canine

Dog Wolf

Feline

Cat Tiger

Rodent

Hamster

Option 1

• All animals inherit behaviour, no need to touch subclasses

• But what does it mean to play with an Animal? Surely we would play differently with a Dog than a Hamster?

Animal

Canine

Dog Wolf

Feline

Cat Tiger

Rodent

Hamster

• Put methods in Animal class

Option 2• All animals inherit

behaviour, they implement their own version at the first concrete subclass

• But does it make sense to play will all types of Animal? It doesn’t sound very safe to play with a Tiger!

Animal

Canine

Dog Wolf

Feline

Cat Tiger

Rodent

Hamster

• Put methods in Animal class but mark them as abstract

Option 3• Only animals you want to

have the methods will have them

• You can’t use Polymorphism at all – as no superclasses have the play method

• So you’d have to write specific code for each subtype of Animal that you could play with

Animal

Canine

Dog Wolf

Feline

Cat Tiger

Rodent

Hamster

• Put methods in only the classes that need the behaviour

Any other ideas?

• Make your suggestions

• What can we do to solve this?

New Pet Class

• It sounds like we need a separate super class:

Animal

Canine

Dog Wolf

Feline

Cat Tiger

Rodent

Hamster

Pet

Multiple Inheritance vs. Interfaces

Multiple inheritance

• In Java, multiple inheritance is not allowed• This is because it gets hard to resolve clashes

Class A

Class B

foo()

Class C

foo()

Class DIf foo() is called on an object of type D, which method gets called?

Interfaces

• Java provides Interfaces to allow you to solve this problem without introducing any of the awkward questions about clashing methods

• An Interface behaves like a 100% abstract class– i.e. containing only abstract methods

• A Class can only extend one other Class, but it can implement many Interfaces

• An Interface is like a contract, any class that implements that Interface guarantees to provide code for its methods

public interface Pet{void play();

}

public class Dog extends Canine implements Pet {//code omitted

public void play(){System.out.println(“Dog plays with a ball”);

}}

public class Cat extends Feline implements Pet {//code omitted

public void play(){System.out.println(“Cat plays with some string”);

}}

public class Hamster extends Rodent implements Pet {//code omitted

public void play(){System.out.println(“Hamster plays on its wheel”);

}}

The interface declaration looks very like a class. All methods are automatically public and abstract

Remember that each class can extend only one superclass, but can implement many interfaces

public void playWithAnyTwoPets(Pet petOne, Pet petTwo){System.out.println(“Lets play with our pets”);

petOne.play();petTwo.play();

}

public static void main(String [ ] args) {Dog dog = new Dog(“Fido”);Cat cat = new Cat(“Mr Tiddles”);Hamster hamster = new Hamster(“Hammy”);

playWithAnyTwoPets(dog, cat);playWithAnyTwoPets(cat, hamster);playWithAnyTwoPets(hamster, dog);

}

Elsewhere in our code we can use interfaces anywhere where we might use a class

Here it is used as a parameter – so this method will accept any class that implements the Pet interface

We cannot create an instance of a Pet, however we can create instances of classes that implement Pet

And pass them as a parameter when a Pet is expected (just like passing a subclass when a superclass is expected)

Extend vs. Implements

• Extend means to add additional behaviour or data (methods or member variables)

• Implements means to provide implementation for a set of methods

• A Class can extend one other class• A Class can implement many Interfaces

Extend vs. Implements

• Extend means to add additional behaviour or data (methods or member variables)

• Implements means to provide implementation for a set of methods

• A Class can extend one other class• A Class can implement many Interfaces

• An Interface can also extend many other Interfaces!

public interface Pet {void play();

}

public interface CagedPet extends Pet {void takeOutOfCage();void putInCage();

}

public class Hamster extends Rodent implements CagedPet {//code omittedprivate boolean inCage = true;

public void play() {if(inCage)

System.out.println(“Hamster plays on its wheel”);else

System.out.println(“Hamster trundles in its ball”);}

public void takeOutOfCage() {inCage = false;

}

public void putInCage () {inCage = true;

}

}

Here CagedPet extends Pet which means that classes that implement CagedPet must provide all three methods

Each class that implements CagedPet is free to implement those methods however it sees fit

Summary

• Abstract Classes and Methods

• The Challenges of Object Oriented Design– Pets vs. Animals

• Multiple Inheritance vs. Interfaces