8. Interfaces & Inner Classes

Transcription

1 8. Interfaces & Inner Classes 1

2 In Chapter 7 you learned about the abstract keyword, which allows you to create one or more methods in a class that have no definitions. The interface keyword produces a completely abstract class, one that provides no implementation at all. It allows you to perform a variation on C++ s multiple inheritances by creating a class that can be upcast to more than one base type. 2

3 Interfaces The interface keyword takes the abstract concept one step further. You could think of it as a pure abstract class. It allows the creator to establish the form for a class: method names, argument lists, and return types, but no method bodies. An interface can also contain fields, but these are implicitly static and final. An interface provides only a form, but no implementation. An interface says, This is what all classes that implement this particular interface will look like. To create an interface, use the interface keyword instead of the class keyword. To make a class that conforms to a particular interface (or group of interfaces), use the implements keyword. 3

4 4

5 interface Instrument { // Compile-time constant: int I = 5; // static & final // Cannot have method definitions: void play(note n); String what(); void adjust(); class Wind implements Instrument { public void play (Note n) { System.out.println("Wind.play() " + n); public String what() { return "Wind"; public void adjust() { class Percussion implements Instrument { public void play (Note n) { System.out.println("Percussion.play() " + n); public String what() { return "Percussion"; public void adjust() { class Stringed implements Instrument { public void play (Note n) { System.out.println( Stringed.play() " + n); public String what() { return Stringed"; public void adjust() { 5

6 class Brass extends Wind { public void play (Note n) { System.out.println( Brass.play() " + n); public void adjust() { System.out.println ( Brass.adjust() ); class Woodwind extends Wind { public void play (Note n) { System.out.println( Woodwind.play() " + n); public String what() { return Woodwind ; public class Music5 { static void tune(instrument i) { //... i.play(note.middle_c); static void tuneall (Instrument[] e) { for (int i = 0; i < e.length; i++) tune(e[i]); public static void main (String[] args) { // Upcasting during addition to the array: Instrument[] orchestra = { new Wind(), new Percussion(), new Stringed(), new Brass(), new Woodwind() ; tuneall(orchestra); 6

7 Multiple inheritance in Java Because an interface has no implementation at all that is, there is no storage associated with an interface there s nothing to prevent many interfaces from being combined. This is valuable because there are times when you need to say An x is an a and a b and a c. In C++, this act of combining multiple class interfaces is called multiple inheritance. It carries some rather sticky baggage because each class can have an implementation. In Java, you can perform the same act, but only one of the classes can have an implementation. 7

8 In Java, If you inherit from a non-interface, you can inherit from only one. All the rest of the base elements must be interfaces. 8

9 interface CanFight { void fight(); interface CanSwim { void swim(); interface CanFly { void fly(); class ActionCharacter { public void fight() { class Hero extends ActionCharacter implements CanFight, CanSwim, CanFly { public void swim() { public void fly() { public class Adventure { public static void t (CanFight x) { x.fight(); public static void u (CanSwim x) { x.swim(); public static void v (CanFly x) { x.fly(); public static void w (ActionCharacter x) { x.fight(); public static void main(string[] args) { Hero h = new Hero(); t(h); // Treat it as a CanFight u(h); // Treat it as a CanSwim v(h); // Treat it as a CanFly w(h); // Treat it as an ActionCharacter 9

10 Extending an interface with inheritance You can easily add new method declarations to an interface by using inheritance. You can also combine several interfaces into a new interface with inheritance. 10

11 interface Monster { void menace(); interface DangerousMonster extends Monster { void destroy(); interface Lethal { void kill(); interface Vampire extends DangerousMonster, Lethal { void drinkblood(); class DragonZilla implements DangerousMonster { public void menace() { public void destroy() { class VeryBadVampire implements Vampire { public void menace() { public void destroy() { public void kill() { public void drinkblood() { public class HorrorShow { static void u (Monster b) { b.menace(); static void v (DangerousMonster d) { d.menace(); d.destroy(); static void w (Lethal l) { l.kill(); public static void main(string[] args) { DangerousMonster barney = new DragonZilla(); u (barney); v (barney); Vampire vlad = new VeryBadVampire(); u (vlad); v (vlad); w (vlad); 11

12 Example: DrawableCircle 12

13 public abstract class Shape { protected int x, y; public abstract double area(); public abstract double circumference(); public void move (int x1, int y1) { x += x1; y += y1; import java.awt.graphics; interface Drawable { void paint(graphics g); public class Circle exrtends Shape { public Circle () { r = 0; public double circumference () { return Math.PI * 2 * r; public double area () { return Math.PI * r * r; public int getradius () { return r; public void setradius (int r) { this.r = r; import java.awt.*; public class DrawableCircle extends Circle implements Drawable { public DrawableCircle() { this(0, 0, 0); public DrawableCircle (int x, int y, int r) { super(r); this.x = x; this.y = y; public void paint(graphics g) { g.drawoval (x-r, y-r, 2*r, 2*r); g.drawstring (String.valueOf(area()), x-r, y); 13