LECTURE 9:INTERFACES & ABSTRACT CLASSES

CSC 212 – Data Structures

Inheritance Issues

Multiple inheritance causes many problems What if field declared in multiple

superclasses? Which constructor will super() chain to? Java avoid by requiring classes extend

exactly 1 class Often mix multiple ideas within a classpublic class Student { … }

public class Employee { … }

public class StudentEmployee extends

abstract

Can declare methods as abstract Methods cannot be defined; promise

functionality Methods can have parameters, throw

exceptions, etc.public abstract void foo(int i);public abstract Beer bar(String o);

Undefined abstract methods make class abstract Cannot instantiate any abstract class Can have fields & normal methods also

allowed Subclasses can override abstract

methods Subclass abstract if not overriding all

abstract methods

Interfaces in Real World

Interfaces

Declare important constant fields public static final must be used for

fields Declare public abstract methods

Methods callable anywhere by any class But method’s body cannot be defined in

interface Classes implement interfaces

Implementing classes define interface’s methods

Avoids problem of multiple inheritance No problem implementing more than 1

interface Unrelated to superclass choice for a class

Adding to an Interface

Interfaces have sub-interfaces Sub-interface extends super-interface Super-interface’s methods inherited by sub-

interface Inherits methods from super-super-

interface, too Sub-interface can extend multiple

interfaces Methods are not defined so this is legal Similar to how classes implement multiple

interfaces Must implement all interface’s methods

Includes methods inherited from super-interface

Also requires implementing interface’s methods

Declaring Interfaces

public interface Drawable { public void setColor(Color c); public Color getColor(); public void draw(Graphics g);}

public interface TranDraw extends Drawable{ public void setTransparency(int tLevel);}

public interface MoveDraw extends Drawable{ public void setPosition(int x, int y);

}

Implementing Interfaces

public class Square implements Drawable {private Color c;private int x, y, side;

public Square(Color col, int len) { c = col; side = len;}

public void setColor(Color col){ c=col; }public Color getColor() { return c; }public void draw(Graphics g) { g.drawRect(x, y, side, side, c);}

}

Using Interfaces

Cannot instantiate an interface… Can only ever create instances of a class

…but can have variables of interface type Instance of classes implementing interface

referenced Methods must be implemented by classes

public void drawRed(Drawable d, Graphics g) {d.setColor(Color.red);d.draw(g);

}

Interface vs. Abstract Class Concepts serve similar purposes

Cannot instantiate either of these types Both used for variable, field, & parameter

types Can extend classes only

Only classes have fields & method bodies Use abstract class when…

Classes need method or private field in common

… in all other cases use an interface

Typecasting

Shape poly = new Square();Square s = poly;Square s = ((Square)poly);

Directs Java to compile illegal code Errors occur at runtime instead

This code compiles, but still illegal

int i = 9;Square s = ((Square)i);

Narrowing Conversions

Java cannot compile narrowing conversions Assigns superclass/interface to lower

variable Compiler will not allow it, but could be

legal Typecasting required for these assignments

Object obj = new String(“bye”);

String sad = obj; // Does not work

String glad = (String)obj; // works!

Before Next Lecture…

Finish work on week #3 homework Continue working on program

assignment #1 Readings for Wed. on Angel/web’s

schedule page I will be posting code, but there will not be

slides… Discuss how to write GUI programs Learning Java’s Swing classes