INTERFACE WHY INTERFACE

Transcription

1 INTERFACE WHY INTERFACE Interfaces allow functionality to be shared between objects that agree to a contract on how the software should interact as a unit without needing knowledge of how the objects accomplish their task. Designing to a Java Interface comes from the slogan: Program to the interface, not the implementation! When you write a class that depends on another, collaborator class, you should rely on the collaborator s interface its specification and not its coding (its implementation). This way you design classes separately yet the assembled collection works A higher level of abstraction allows us to utilize methods and classes with a higher degree of commonality. Structures and approaches can be shared in a wider variety of implementations. You can reuse frameworks of the past and improve on functionality without having to make any changes to already existing work. You simply improve on the next iteration Cleanly separates implementation of behavior from description of the behavior Means the implementation is easily changed Vehicle vehicle = new MotorBike(); // might become Vehicle vehicle = new MotorCar(); Many Object Oriented systems are defined almost entirely of interfaces Describes how the system will function The actual implementation is introduced later A class can only extend one other class, but it can implement multiple interfaces. In effect using interfaces gives us the benefit of multiple inheritance without many of its problems. You can write methods that work for more than one kind of class

2 INTERFACE FEATURES A Java interface is a collection of abstract methods and constants. An abstract method is a method header without a method body. An abstract method can be declared using the modifier abstract, but because all methods in an interface are abstract, usually it is left off. An interface is used to establish a set of methods that a class will implement. An interface cannot be instantiated. Methods in an interface have public visibility by default. A class formally implements an interface by: stating so in the class header. providing implementations for each abstract method in the interface. A class can implement multiple interfaces. A class can implement any number of interfaces. Interfaces are compiled into bytecode just like classes. Can use interface as a data type for variables. Can also use an interface as the result of a cast operation. The interfaces are listed in the implements clause. HOW TO DEFINE AN INTERFACE? interface is a reserved word public interface Doable { void dothis(); int dothat(); void dothis2 (float value, char ch); boolean dotheother (int num); None of the methods in an interface are given a definition (body), because they are by default abstract methods

3 CLASS AND INTERFACE FEATURES The class must implement all methods in all interfaces listed in the header OR declare itself to be abstract. Classes can implement any number of interfaces public class MotorBike implements Vehicle, Motorised Possible to combine extends and implements public class MotorBike extends WheeledVehicle implements Vehicle, Motorised { // Implement all methods of both interfaces EXAMPLE OF INHERITANCE public interface OperateCar { // constant declarations, if any // method signatures int turn(direction direction, double radius, double startspeed, double endspeed); int changelanes(direction direction, double startspeed, double endspeed); int signalturn(direction direction, boolean signalon); int getradarfront(double distancetocar, double speedofcar); int getradarrear(double distancetocar, double speedofcar);... // more method signatures

4 public class BMWCar implements OperateCar { int signalturn(direction,speed){ // proprietary code to signal you are turning // override all the other methods A Toyota manufacturer may have different positioning of the signals on the car, different signal colors, different light intensity, but it is guaranteed that when you use signalturn you will get the same behavior as the BMW car. ANOTHER EXAMPLE There are a number of situations in software engineering when it is important for disparate groups of programmers to agree to a "contract" that spells out how their software interacts. Each group should be able to write their code without any knowledge of how the other group's code is written. Generally speaking, Interfaces are such contracts. Check the following Imagine a futuristic society where computer-controlled robotic cars transport passengers through city streets without a human operator. Automobile manufacturers write software that operates the automobile stop, start, accelerate, turn left, and so forth. Another industrial group, electronic guidance instrument manufacturers, make computer systems that receive GPS (Global Positioning System) position data and wireless transmission of traffic conditions and use that information to drive the car. The auto manufacturers must publish an industry-standard interface that spells out in detail what methods can be invoked to make the car move (any car, from any manufacturer). The guidance manufacturers can then write software that invokes the methods described in the interface to command the car. Neither industrial group needs to know how the other group's software is implemented.

5 In fact, each group considers its software highly proprietary and reserves the right to modify it at any time, as long as it continues to adhere to the published interface. INHERITANCE & INTERFACE Java does not permit multiple inheritance like C++. Some people would say that is a weakness of Java, but there is an alternative view that says Java s interfaces give the advantages of multiple inheritance while avoiding some of the problems. One of the key problems with multiple inheritance is known as the diamond problem. It occurs when a class inherits from two classes with a common ancestor. In this following diagram which represents the diamond problem, when a class inherits from two classes that implement common methods in different ways, what does it inherit? Engine Ignition Gas Engine Ignition: spark plugs Diesel Engine Ignition: glow plugs Multi Fuel Engine Ignition:

6 Java solves the diamond problem by not allowing multiple inheritance from ancestors that have any implementation details. Thus, in Java, classes can only multiply inherit from interfaces and abstract classes that have no implementation details. One interface can inherit another by use of the keyword extends. When a class implements an interface that inherits another interface, it must provide implementations for all methods defined within the interface inheritance chain. Why would we need to have one interface inherit from another instead of modifying the original one? Because all of the implementations we have written in the past would now break. Not all methods would be implemented and we would have to revisit past work. To solve this problem without breaking our previous work, we create a new interface that extends the original one to add new functionality to our design. interface AnyKid { void maycry(); interface MyKid extends AnyKid { void issmart(); How do we use the new features that were added in a new class implementation? class MySon implements MyKid { public void maycry(){ System.out.println( Its ok ); public void issmart() { System.out.println( But he is certainly VERY smart );

7 A class can also implement more than one pertinent interface at the same time but cannot inherit from more than one other class. For a class to inherit from two interfaces, it must provide implementation for all methods declared in each interface. public class StudentEmployee implements Student, Employee { implement all methods from both interfaces here. If there is a conflicting method defined in both interfaces the compiler will let us know INTERFACE VS. ABSTRACT CLASS Interfaces define a contract Contain methods and their signatures Can also include static final constants (and comments) But no implementation Very similar to abstract classes One interface can extend another, but An interface cannot extend a class A class cannot extend an interface Classes implement an interface. An interface cannot have any methods implemented, whereas an abstract class can. A class can implement many interfaces but can only inherit from one superclass. An interface is not part of the class hierarchy. Unrelated classes can implement the same interface. Use an abstract class when you want a roadmap for a collection of subclasses. Subclass when you want to extend a class and add some functionality, whether or not the parent class is abstract.

8 Define an interface when there is no common parent class with the desired functionality, and when you want only certain unrelated classes to have that functionality. Use interfaces as markers to indicate something about a class (e.g. Cloneable be able to make a copy). A common design pattern is to use both an interface and an abstract class depending on the needs of the project. All classes share a single root, the Object class, but there is no single root for interfaces. As a summary. Data Member/ Fields Methods Inheritance Interface Only constants No implementation allowed (no abstract modifier necessary) A subclass can implement many interfaces Abstract class Constants and variable data Abstract or concrete A subclass can inherit only one class Can extend numerous interfaces Cannot extend a class Can implement numerous interfaces Extends one class Root none Object (of all classes) CONSTANTS IN INTERFACE interface OlympicMedal { static final String GOLD = "Gold"; static final String SILVER = "Silver"; static final String BRONZE = "Bronze";

9 public final class OlympicAthlete implements OlympicMedal { public OlympicAthlete(int aid){ //..elided //..elided public void winevent(){ //the athlete gets a gold medal //note the reference is NOT qualified, as //in OlympicMedal.GOLD fmedal = GOLD; // PRIVATE private String fmedal; //possibly null INTERFACES TO USE The Java standard class library contains many helpful interfaces. We will go over three of them: Comparable, Comparator and Cloneable Interface. THE COMPARABLE INTERFACE The Comparable interface contains One abstract method called compareto, which is used to compare two objects. This method compares two objects, in order to impose an order between them. Specifically, it returns one of the following: a negative integer, zero or a positive integer to indicate that the input object is less than, equal or greater than the existing object. Any class can implement Comparable to provide a mechanism for comparing objects of that type if (obj1.compareto(obj2) < 0) System.out.println ("obj1 is less than obj2");

10 The value returned from compareto should be negative is obj1 is less that obj2, 0 if they are equal, and positive if obj1 is greater than obj2 When a programmer designs a class that implements the Comparable interface, it should follow this intent It's up to the programmer to determine what makes one object less than another For example, you may define the compareto method of an Employee class to order employees by name (alphabetically) or by employee number The implementation of the method can be as straightforward or as complex as needed for the situation. Here is an Example: public class Person implements Comparable <Person> { private String name; private int age; public Person(String name, int age) { this.name = name; this.age = age; public int getage() { return this.age; public String getname() { return this.name; public String tostring() { return ""; public int compareto(person per) { int result=-1; if(this.name.equals (per.getname())==true) result =0; else{ if (this.age > per.getage) { result =1; return result

11 // Testing the compareto method public static void main(string[] args) { Person e1 = new Person("Adam", 45); Person e2 = new Person("Steve", 60); int retval = e1.compareto(e2); switch(retval) { case 0: System.out.println(e1.getName()+" has the same name as + e2.getname() ); break; case -1: { System.out.println("The " + e2.getname() + " is older!"); break; case 1: { System.out.println("The " + e1.getname() + " is older!"); break; Output Steve is older!

12 2. COMPARATOR INTERFACE Comparator interface, which contains two methods, called compare and equals. The compare method compares its two input arguments and imposes an order between them. It returns a negative integer, zero, or a positive integer to indicate that the first argument is less than, equal to, or greater than the second. There should be two classes. The equals method requires an Object as a parameter and aims to decide whether the input object is equal to the comparator. The method returns true, only if the specified object is also a comparator and it imposes the same ordering as the comparator. Here is an Example: public class Company { private int num_of_employess; private String name; public Company(String name, int num_of_employess) { this.name = name; this.num_of_employess = num_of_employess; public int getnumofemployess() { return this.num_of_employess; public String getname() { return this.name;

13 import java.util.comparator; public class SortCompanies implements Comparator <Company> { public int compare (Company comp1, Company comp2) { if(comp1.getnumofemployess()== comp2.getnumofemployess()) return 0; else return comp1.getnumofemployess() > comp2.getnumofemployess()? 1 : -1; public static void main(string[] args) { Company comp1 = new Company("Company1", 20); Company comp2 = new Company("Company2", 15); SortCompanies sortcmp = new SortCompanies(); int retval = sortcmp.compare(comp1, comp2); switch(retval) { case -1: { System.out.println("The " + comp2.getname() + " is bigger!"); break; case 1: { System.out.println("The " + comp1.getname() + " is bigger!"); break; default: System.out.println("The two companies are of the same size!");

14 3. CLONEABLE INTERFACE Cloneable interface which contains the following: The clone method which takes no parameters and it returns back an object of the class Object. The method is used to create a copy of the current object. The method gives back an object of the class Object. The method throws CloneNotSupportedException Here is an Example: public class Employee implements Cloneable { private String firstname; private String lastname; private double salary; Employee() { setfirstname(""); setlastname(""); setsalary(0); Employee(String fname, String lname, double newsalary) { setfirstname(fname); setlastname(lname); setsalary(newsalary); public String tostring() { return "Employee [firstname=" + getfirstname() + ", lastname=" + getlastname() + ", salary=" + getsalary() + "]"; public String getfirstname() { return firstname; public void setfirstname(string firstname) { this.firstname = firstname;

15 public String getlastname() { return lastname; public void setlastname(string lastname) { this.lastname = lastname; public double getsalary() { return salary; public void setsalary(double newsalary) { salary = newsalary; public Object clone() throws CloneNotSupportedException{ return super.clone(); public class TestEmployees { public static void main(string[] args) { Employee e1 = new Employee ("Tom", "Adam", 5000); try { Employee e3 = (Employee) e1.clone(); e3.setfirstname("william"); System.out.println(e1); System.out.println(e3); catch (CloneNotSupportedException c) { System.out.println( An error )

16 DIFFERENCES BETWEEN VARIABLES OF PRIMITIVE TYPES AND REFERENCE TYPES Every variable represents a memory location that holds a value. When you declare a variable, you are telling the compiler what type of value the variable can hold. For a variable of a primitive type, the value is of the primitive type. For a variable of a reference type, the value is a reference to where an object is located. The default value of a data field is null for a reference type, The default value of a variable of primitive data type is 0 for a numeric type, false for a boolean type, and \u0000 for a char type CREATING A COPY OF AN OBJECT When you try to try to copy an object to another object, then dont use = between these two objects. For example: Person P1; Person P2; P2 = P1;

17 This is wrong approach to copy the content of P1 into P2. Instead, you are letting both objects references pointing to the same location. Which means if P2 change something, P1 will be affected. To create a copy of an object, use of the following ways. 1. MANUALLY USING MUTATORS AND ACCESSORS. Create the first object, then declare the second one and after that copy data from object1 into object2 through using mutators method for object2 and accessors methods for object1. 2. USING A COPY CONSTRUCTOR. 3. USE.CLONE() METHOD Check the following Example: public class Employee implements Cloneable { private String firstname; private String lastname; private double salary; Employee() { setfirstname(""); setlastname(""); setsalary(0); Employee(String fname, String lname, double newsalary) { setfirstname(fname); setlastname(lname); setsalary(newsalary); // Copy constructor Employee (Employee newemployee) { setfirstname(newemployee.getfirstname()); setlastname(newemployee.getlastname()); setsalary(newemployee.getsalary());

18 public String tostring() { return "Employee [firstname=" + getfirstname() + ", lastname=" + getlastname() + ", salary=" + getsalary() + "]"; public String getfirstname() { return firstname; public void setfirstname(string firstname) { this.firstname = firstname; public String getlastname() { return lastname; public void setlastname(string lastname) { this.lastname = lastname; public double getsalary() { return salary; public void setsalary(double newsalary) { salary = newsalary; public Object clone() throws CloneNotSupportedException{ return super.clone(); public class TestEmployees { public static void main(string[] args) { Employee e1 = new Employee ("Tom", "Adam", 5000); Employee e2 = new Employee ("Tom", "Adam", 5000); /* You can t copy e1 to e3 using = as follows // e3 and e1 share the same object Employee e3 = e1;

19 e3.setfirstname("rayan"); System.out.println(e1); */ /* // you can use copy constructor as follow // e3 is an independent copy of e1 Employee e3 = new Employee (e1); e3.setfirstname("rayan"); System.out.println(e1); */ /* // Or you can use.clone try{ Employee e3 = (Employee) e1.clone(); e3.setfirstname("rayan"); System.out.println(e1); System.out.println(e3); catch(clonenotsupportedexception c){ /*

20 COMPARE BETWEEN TWO OBJECTS When you compare between two Objects don t use ==. If you are using == then you are comparing the 2 references not their contents. Instead, use the following. The class object (the root of all the classes) has a special method called.equals which you can use to compare two objects based on their content. You have to override this method in the class of the objects that you are trying to compare between. The method.equals defines a method parameter of type Object and its return type is boolean. public boolean equals(object anobject) {... Check the following Example: public class Employee implements Cloneable { private String firstname; private String lastname; private double salary; Employee() { setfirstname(""); setlastname(""); setsalary(0); Employee(String fname, String lname, double newsalary) { setfirstname(fname); setlastname(lname); setsalary(newsalary); Employee (Employee newemployee) { setfirstname(newemployee.getfirstname()); setlastname(newemployee.getlastname()); setsalary(newemployee.getsalary());

21 public String tostring() { return "Employee [firstname=" + getfirstname() + ", lastname=" + getlastname() + ", salary=" + getsalary() + "]"; public String getfirstname() { return firstname; public void setfirstname(string firstname) { this.firstname = firstname; public String getlastname() { return lastname; public void setlastname(string lastname) { this.lastname = lastname; public double getsalary() { return salary; public void setsalary(double newsalary) { salary = newsalary; public boolean equals (Object other){ boolean result; if((other == null) (getclass()!= other.getclass())){ result = false; // end if else{ Employee otheremployee = (Employee)other; result = firstname.equals(otheremployee.getfirstname()) && lastname.equals(otheremployee.getlastname()) && salary == otheremployee.getsalary(); // end else return result; // end equals

22 public class TestEmployees { public static void main(string[] args) { Employee e1 = new Employee ("Tom", "Adam", 5000); Employee e2 = new Employee ("Tom", "Adam", 5000); // You cant use the following to compare between the contents of e1 and e2 if (e1==e2) { System.out.println("e1 and e2 have the same address"); else{ System.out.println("e1 has different address than e2"); // You have to use.equals methods to compare between the content of e1 // and e2 if (e1.equals(e2)) { System.out.println("e1 has the same data members values as e2"); else{ System.out.println("e1 has different data members values than e2");

23 REFERENCES