Date post: | 19-Jul-2016 |
Category: |
Documents |
Upload: | ninah-reyes |
View: | 6 times |
Download: | 1 times |
IMPLEMENTING AN
INTERFACE
In Java, a class can inherit from a
superclass that has inherited from another
superclass — this represents single
inheritance with multiple generations. What
Java does not allow is for a class to inherit
directly from two or more parents.
Dealing with the possibility that
variables and methods in the parent classes
might have identical names, it might create a
conflict when the child class uses one of the
names. Also, when there are two or more
parents, which class should super() refer
when a child class has multiple parents? For
these reasons, multiple inheritance is
prohibited in Java.
The capability to inherit from more than
one class is called multiple inheritance.
Java, however, does provide an
alternative to multiple inheritance—an
interface.
An interface looks much like a class,
except that all of its methods (if any) are
implicitly public and abstract, and all of its
data items (if any) are implicitly public, static,
and final.
An interface declares method headers,
but not the instructions within those methods.
When you create a class that uses an
interface, you include the keyword
implements and the interface name in the
class header. This notation requires the class to
include an implementation for every method
named in the interface.
Whereas using extends allows a
subclass to use nonprivate, nonoverridden
members of its parent’s class, implements requires the subclass to implement its own
version of each method
EXAMPLE 1: public abstract class Animal{ private String name; public abstract void speak(); public String getName() { return name; } public void setName(String animalName){ name = animalName; } } public class Dog extends Animal{ public void speak(){ System.out.println("Woof!"); } }//Dog inherits Animal
//create interface public interface Worker{ public void work(); }
/*this example gives the Worker interface a single
method named work(). When any class implements
Worker, it must either include a work() method or the
new class must be declared abstract, and then its
descendants must implement the method.*/
public class WorkingDog extends Dog implements Worker{ private int hoursOfTraining; public void setHoursOfTraining(int hrs{ hoursOfTraining = hrs; } public int getHoursOfTraining(){ return hoursOfTraining; } public void work(){ speak(); System.out.println("I am a dog who works"); System.out.println("I have " + hoursOfTraining + " hours of professional training!"); } }
/*Because the WorkingDog class implements the
Worker interface, it also must contain a work()
method that calls the Dog speak() method, and then
produces two more lines of output—a statement
about working and the number of training hours.*/
/*Note:
A class can extend another class without
implementing any interfaces. A class can also
implement an interface even though it does not
extend any other class. When a class both extends
and implements, like the WorkingDog class, by
convention the implements clause follows the
extends clause in the class header.*/
public class DemoWorkingDogs{ public static void main(String[] args){ WorkingDog aSheepHerder=new WorkingDog(); WorkingDog aSeeingEyeDog = new WorkingDog(); SheepHerder.setName("Simon, the Border Collie"); SeeingEyeDog.setName("Sophie,the German Shepherd"); SheepHerder.setHoursOfTraining(40); System.out.println(SheepHerder.getName()+"says"); aSheepHerder.speak();
aSheepHerder.work(); System.out.println();
System.out.println(aSeeingEyeDog.getName()+"says"); aSeeingEyeDog.speak(); aSeeingEyeDog.work(); } }
/*The DemoWorkingDogs instantiates two WorkingDog objects.
Each object can use the following methods:
The setName() and getName() methods that WorkingDog
inherits from the Animal class
The speak() method that WorkingDog inherits from the Dog
class
The setHoursOfTraining()and getHoursOfTraining() methods
contained within the WorkingDog class
The work() method that the WorkingDog class was required
to contain when it used the phrase implements Worker; the work()
method also calls the speak() method contained in the Dog
class*/
OUTPUT:
Example 2 public interface Relatable { // this (object calling isLargerThan) // and other must be instances of // the same class returns 1, 0, -1 // if this is greater than, // equal to, or less than other public int isLargerThan(Relatable other); } public class RectanglePlus implements Relatable { public int width = 0; public int height = 0; public Point origin; // four constructors public RectanglePlus() { origin = new Point(0, 0); }
public RectanglePlus(Point p){ origin = p; } public RectanglePlus(int w, int h){ origin = new Point(0, 0); width = w; height = h; } public RectanglePlus(Point p, int w, int h){ origin = p; width = w; height = h; } //a method for moving the rectangle public void move(int x, int y){ origin.x = x; origin.y = y; }
// a method for computing // the area of the rectangle public int getArea(){ return width * height; } // a method required to implement // the Relatable interface public int isLargerThan(Relatable other){ RectanglePlus otherRect = (RectanglePlus)other; if (this.getArea() < otherRect.getArea()) return -1; else if (this.getArea() > otherRect.getArea())
return 1; else return 0; } }
//Because RectanglePlus implements Relatable, the
//size of any two RectanglePlus objects can be
//compared.
Using an Interface as a Type
When you define a new interface, you
are defining a new reference data type. You
can use interface names anywhere you can
use any other data type name. If you define a
reference variable whose type is an interface,
any object you assign to it must be an
instance of a class that implements the
interface.
/*a method for finding the largest object in a pair of
objects, for any objects that are instantiated from a
class that implements Relatable*/
public Object findLargest(Object object1, Object object2){ Relatable obj1 = (Relatable)object1; Relatable obj2 = (Relatable)object2; if ((obj1).isLargerThan(obj2) > 0) return object1; else return object2; }
/*By casting object1 to a Relatable type, it can invoke
the isLargerThan method.*/
Evolving Interfaces
Consider an interface that you have
developed called DoIt:
public interface DoIt { void doSomething(int i, double x); int doSomethingElse(String s); }
Suppose that, at a later time, you want
to add a third method to DoIt, so that the
interface now becomes:
public interface DoIt{ void doSomething(int i, double x); int doSomethingElse(String s); boolean didItWork(int i, double x, String s); }
If you make this change, then all
classes that implement the old DoIt interface
will break because they no longer implement
the old interface.
Try to anticipate all uses for interface
and specify it completely from the beginning.
Create a DoItPlus interface that extends DoIt:
public interface DoItPlus extends DoIt { boolean didItWork(int i, double x, String s); }
Abstract Classes vs. Interfaces
• Abstract classes and interfaces are similar
in that you cannot instantiate concrete
objects from either one.
• Abstract classes differ from interfaces
because abstract classes can contain
nonabstract methods, but all methods
within an interface must be abstract.
• A class can inherit from only one abstract
superclass, but it can implement any
number of interfaces.
Creating Interfaces to Store Related Constants
Interfaces can contain data fields, but they
must be public, static, and final.
• Public:
interface methods cannot contain
method bodies; without public method
bodies, you have no way to retrieve private
data
• Static:
you cannot create interface objects
• Final:
without methods containing bodies, you
have no way, other than at declaration, to
set the data fields’ values, and you have no
way to change them
Example: public interface PizzaConstants{ public static final int SMALL_DIAMETER = 12; public static final int LARGE_DIAMETER = 16; public static final double TAX_RATE = 0.07; public static final String COMPANY = "Antonio's Pizzeria"; }
public class PizzaDemo implements PizzaConstants{ public static void main(String[] args){ double specialPrice = 11.25;
System.out.println("Welcome to "+COMPANY); System.out.println("We are having a special offer:\na "+ SMALL_DIAMETER +" inch pizza with four toppings\nor a " + LARGE_DIAMETER + " inch pizza with one topping\nfor only $" + specialPrice); System.out.println("With tax, that is only $" + (specialPrice + specialPrice * TAX_RATE)); } }
OUTPUT:
More examples:
public interface Relatable { /* this (object calling isLargerThan) and other must be instances of the same class returns 1, 0, -1 if this is greater than, equal to, or less than other */ public int isLargerThan(Relatable other); }// public interface Relatable
public class RectanglePlus implements Relatable { public int width = 0; public int height = 0; public Point origin; //four constructors public RectanglePlus() { origin = new Point(0, 0); }
public RectanglePlus(Point p) { origin = p; } public RectanglePlus(int w, int h) { origin = new Point(0, 0); width = w; height = h; } public RectanglePlus(Point p, int w, int h) { origin = p; width = w; height = h; } //a method for moving the rectangle public void move(int x, int y) { origin.x = x; origin.y = y; }
//a method for computing the area of the rectangle public int getArea() { return width * height; } //a method to implement Relatable interface public int isLargerThan(Relatable other) { RectanglePlus otherRect=(RectanglePlus)other; if (this.getArea() < otherRect.getArea()) return -1; else if (this.getArea()>otherRect.getArea()) return 1; else return 0; }// public int isLargerThan(Relatable other) }// public class RectanglePlus implements Relatable
interface Animal { public void eat(); public void travel(); } public class MammalInt implements Animal{ public void eat(){ System.out.println("Mammal eats"); } public void travel(){ System.out.println("Mammal travels"); } public int noOfLegs(){ return 0; } public static void main(String args[]){ MammalInt m = new MammalInt(); m.eat(); m.travel(); } } // public class MammalInt implements Animal
public interface MyInterface { public String hello = "Hello"; public void sayHello(); } public interface MyInterface { public String goodbye = "Goodbye"; public void sayHello(); } public class MyInterfaceImpl implements MyInterface, MyOtherInterface { public void sayHello() { System.out.println(MyInterface.hello); } public void sayGoodbye() { System.out.println(MyInterface.goodbye); } }// public class MyInterfaceImpl implements MyInterface, //MyOtherInterface
References: http://docs.oracle.com/javase/tutorial/java/IandI/
usinginterface.html
http://www.tutorialspoint.com/java/java_interface
s.htm
http://tutorials.jenkov.com/java/interfaces.html#i
mplementating-an-interface
Java Programming 6th Edition by Joyce Farrell
Java: An Introduction to Problem Solving and
Programming 6th Edition by Walter Savitch