Universiti Malaysia Perlis

Transcription

1 Universiti Malaysia Perlis EKT420: SOFTWRE ENGINEERING Lab 5: Inheritance and Interfaces Pusat Pengajian Kejuruteraan Komputer Dan Perhubungan Universiti Malaysia Perlis 1

2 INHERITANCE Object-oriented programming allows classes to inherit commonly used state and behavior from other classes. In this example, Bicycle now becomes the superclass of MountainBike, RoadBike, and TandemBike. In the Java programming language, each class is allowed to have one direct superclass, and each superclass has the potential for an unlimited number of subclasses: Figure 1 A hierarchy of class bicycle The syntax for creating a subclass is simple. At the beginning of your class declaration, use the extends keyword, followed by the name of the class to inherit from: class MountainBike extends Bicycle { // new fields and methods defining a mountain bike would go here This gives MountainBike all the same fields and methods as Bicycle, yet allows its code to focus exclusively on the features that make it unique. Here is the sample code for a possible implementation of a Bicycle class: 2

3 public class Bicycle { // the Bicycle class has three fields public int cadence; public int gear; public int speed; // the Bicycle class has one constructor public Bicycle(int startcadence, int startspeed, int startgear) { gear = startgear; cadence = startcadence; speed = startspeed; // the Bicycle class has four methods public void setcadence(int newvalue) { cadence = newvalue; public void setgear(int newvalue) { gear = newvalue; public void applybrake(int decrement) { speed -= decrement; public void speedup(int increment) { speed += increment; A class declaration for a MountainBike class that is a subclass of Bicycle might look like this: public class MountainBike extends Bicycle { // the MountainBike subclass adds one field public int seatheight; // the MountainBike subclass has one constructor public MountainBike(int startheight, int startcadence, int startspeed, int startgear) { super(startcadence, startspeed, startgear); seatheight = startheight; // the MountainBike subclass adds one method public void setheight(int newvalue) { seatheight = newvalue; 3

4 Accessing Superclass Members If your method overrides one of its superclass's methods, you can invoke the overridden method through the use of the keyword super. You can also use super to refer to a hidden field (although hiding fields is discouraged). Consider this class, Superclass: public class Superclass { public void printmethod() { System.out.println("Printed in Superclass."); Here is a subclass, called Subclass, that overrides printmethod(): public class Subclass extends Superclass { public void printmethod() { //overrides printmethod in Superclass super.printmethod(); System.out.println("Printed in Subclass"); public static void main(string[] args) { Subclass s = new Subclass(); s.printmethod(); Within Subclass, the simple name printmethod() refers to the one declared in Subclass, which overrides the one in Superclass. So, to refer to printmethod() inherited from Superclass, Subclass must use a qualified name, using super as shown. Compiling and executing Subclass prints the following: Printed in Superclass. Printed in Subclass Subclass Constructors The following example illustrates how to use the super keyword to invoke a superclass's constructor. Recall from the Bicycle example that MountainBike is a subclass of Bicycle. Here is the MountainBike (subclass) constructor that calls the superclass constructor and then adds initialization code of its own: public MountainBike(int startheight, int startcadence, int startspeed, int startgear) { super(startcadence, startspeed, startgear); seatheight = startheight; Invocation of a superclass constructor must be the first line in the subclass constructor. The syntax for calling a superclass constructor is super(); --or-- super(parameter list); 4

5 With super(), the superclass no-argument constructor is called. With super(parameter list), the superclass constructor with a matching parameter list is called. Final You can declare some or all of a class's methods final. You use the final keyword in a method declaration to indicate that the method cannot be overridden by subclasses. The Object class does this a number of its methods are final. Methods called from constructors should generally be declared final. If a constructor calls a non-final method, a subclass may redefine that method with surprising or undesirable results. The final variables You can declare a variable constant by using the keyword final. A final variable indicates that the variable is constant. Final float pi = 3.142; Final Methods A subclass cannot override method that are declared final in the superclass. By definition, final methods cannot be overridden. If you attempt to override a final method, the compiler will hightlight an error. Final void MethodName(arguments) { Final classes A final class cannot be subclassed. 5

6 Abstract classes Abstract class means that class is intended to be subclass but cannot be instantiated. The sole purpose of an abstract class is to provide an appropriate superclass from which other classes may inherit with more generic usage. Abstract Method An abstract class may contains abstract methods, i.e. methods with no implementation. The abstract class can leave the implementation details to those methods to its subclasses. An abstract method cannot be private. //livingthing.java // The LivingThing class is an abstract class because // some methods in it are declared as abstract methods. public abstract class LivingThing { private String name; public LivingThing(String name){ this.name = name; public void breath(){ System.out.println("Living Thing breathing..."); public void eat(){ System.out.println("Living Thing eating..."); /** * Abstract method walk() * We want this method to be implemented by subclasses of * LivingThing */ public abstract void walk(); public String getname() { return name; public void setname(string name) { this.name = name; 6

7 //human.java public class Human extends LivingThing { public Human(String name){ super(name); // Provide implementation of the abstract method. public void walk(){ System.out.println("Human " + getname() + " walks..."); public class Monkey extends LivingThing { public Monkey(String name){ super(name); // Implement the abstract method public void walk(){ System.out.println("Monkey " + getname() + " also walks..."); public class Main { public static void main(string[] args) { Human human1 = new Human("Ahmad"); human1.walk(); // Create Human object instance // and assign it to LivingThing type. LivingThing livingthing1 = human1; livingthing1.walk(); // Create a Monkey object instance // and assign it to LivingThing type. LivingThing livingthing2 = new Monkey("MonkeyWrench"); livingthing2.walk(); System.out.println("human1.getName() = " + human1.getname()); System.out.println("livingthing1.getName() = " + livingthing1.getname()); boolean b1 = (human1 == livingthing1); System.out.println("Do human1 and livingthing1 point to the same object instance? " + b1); // Compile error // LivingThing z = new LivingThing(); 7

8 INTERFACES In its most common form, an interface is a group of related methods with empty bodies. A bicycle's behavior, if specified as an interface, might appear as follows: interface Bicycle { void changecadence(int newvalue); void changegear(int newvalue); void speedup(int increment); void applybrakes(int decrement); To implement this interface, the name of your class would change (to ACMEBicycle, for example), and you'd use the implements keyword in the class declaration: class ACMEBicycle implements Bicycle { // remainder of this class implemented as before An interface is essentially a collection of constants and abstracts methods. The constant are implicitly public, static and final. The methods are always public and abstract. An interface provides only a form, but no implementation. When class implements an interface, any constants that were defined in the interface definition are available directly in the class. Each class implements its own version of the interface methods. 8

9 package myrelationinterfaceproject; // Define an interface with three abstract methods. // Any class that implements this interface has to // implement all three methods. public interface RelationInterface { public boolean isgreater( Object a, Object b); public boolean isless( Object a, Object b); public boolean isequal( Object a, Object b); package myrelationinterfaceproject; public class Main { public static void main(string[] args) { // Create two Line object instances. Line line1 = new Line(1.0, 2.0, 1.0, 2.0); Line line2 = new Line(2.0, 3.0, 2.0, 3.0); boolean b1 = line1.isgreater(line1, line2); System.out.println("line1 is greater than line2: " + b1); boolean b2 = line1.isequal(line1, line2); System.out.println("line1 is equal with line2: " + b2); RelationInterface line3 = new Line(1.0, 5.0, 1.0, 5.0); boolean b3 = line3.isequal(line1, line3); System.out.println("line1 is equal with line3: " + b3); System.out.println("Length of line1 is " + line1.getlength()); System.out.println("Length of line2 is " + line2.getlength()); 9

10 package myrelationinterfaceproject; public class Line implements RelationInterface{ private double x1; private double x2; private double y1; private double y2; // Constructor method of the Line class. public Line(double x1,double x2,double y1,double y2){ this.x1 = x1; this.x2 = x2; this.y1 = y1; this.y2 = y2; // A new method definition of the Line class public double getlength(){ double length = Math.sqrt( (x2-x1)*(x2-x1) + (y2-y1)*(y2-y1)); return length; // Implement isgreater(..) method defined in the Relation //interface public boolean isgreater( Object a, Object b){ double alen = ((Line)a).getLength(); double blen = ((Line)b).getLength(); return (alen > blen); // Implement isless(..) method defined in the Relation //interface public boolean isless( Object a, Object b){ double alen = ((Line)a).getLength(); double blen = ((Line)b).getLength(); return (alen < blen); // Implement isequal(..) method defined in the Relation //interface public boolean isequal( Object a, Object b){ double alen = ((Line)a).getLength(); double blen = ((Line)b).getLength(); return (alen == blen); 10