In the Java programming language, an interface is not a class but a set of requirements forclasses that want to conform to the interface.
Typically, the supplier of some service states: “If your class conforms to a particular interface, then I’ll perform the service.” Let’s look at a concrete example. The sortmethod of the Arrays class promises to sort an array of objects, but under one condition:
The objects must belong to classes that implement the Comparable interface.
Here is what the Comparable interface looks like:
This means that any class that implements the Comparable interface is required to have a compare To method, and the method must take an Object parameter and return an integer.
NOTE: As of Java SE 5.0, the Comparable interface has been enhanced to be a generic type. public interface Comparable<T>
For example, a class that implements Comparable<Employee>must supply a method
You can still use the “raw” Comparable type without a type parameter, but then you have to manually cast the parameter of the compareTo method to the desired type.
All methods of an interface are automatically public. For that reason, it is not necessary to supply the keyword public when declaring a method in an interface.
Of course, there is an additional requirement that the interface cannot spell out: When calling x .compareTo(y), the compareTo method must actually be able to compare two objects and return an indication whether x or y is larger. The method is supposed to return a negative number if x is smaller than y, zero if they are equal, and a positive number.
This particular interface has a single method. Some interfaces have more than onemethod. As you will see later, interfaces can also define constants. What is more important, however, is what interfaces cannot supply. Interfaces never have instance fields, and the methods are never implemented in the interface. Supplying instance fields and method implementations is the job of the classes that implement the interface. You can think of an interface as being similar to an abstract class with no instance fields. However, there are some differences between these two concepts—we look at them later in some detail.
Now suppose we want to use the sort method of the Arrays class to sort an array of Employee objects. Then the Employee class must implement the Comparable interface.
To make a class implement an interface, you carry out two steps:
To declare that a class implements an interface, use the implements keyword:
Of course, now the Employee class needs to supply the compareTo method. Let’s suppose that we want to compare employees by their salary. Here is a compareTo method that returns –1 if the first employee’s salary is less than the second employee’s salary, 0 if they are equal, and 1 otherwise.
CAUTION: In the interface declaration, the compareTo method was not declared public because all methods in an interface are automatically public. However, when implementingthe interface, you must declare the method as public. Otherwise, the compiler assumes thatthe method has package visibility —the default for a class. Then the compiler complains thatyou try to supply a weaker access privilege.
As of Java SE 5.0, we can do a little better. We’ll decide to implement the Comparable<Employee>interface type instead.
Note that the unsightly cast of the Object parameter has gone away.
TIP: The compareTo method of the Comparable interface returns an integer. If the objects are not equal, it does not matter what negative or positive value you return. This flexibility can be useful when you are comparing integer fields. For example, suppose each employee has a unique integer id and you want to sort by employee ID number. Then you can simply return id -other.id. That value will be some negative value if the first ID number is less than the other, 0 if they are the same ID, and some positive value otherwise. However, there is one caveat: The range of the integers must be small enough that the subtraction does not overflow. If you know that the IDs are not negative or that their absolute value is at most (Integer .MAX _VALUE - 1) / 2, you are safe.
Of course, the subtraction trick doesn’t work for floating-point numbers. The difference salary - other. salary can round to 0 if the salaries are close together but not identical.
Now you saw what a class must do to avail itself of the sorting service —it must implement a compare To method. That’s eminently reasonable. There needs to be some way for the sort method to compare objects. But why can’t the Employee class simply provide a compareTo method without implementing the Comparable interface?
The reason for interfaces is that the Java programming language is strongly typed. When making a method call, the compiler needs to be able to check that the method actually exists. Somewhere in the sort method will be statements like this:
The compiler must know that a[i] actually has a compareTo method. If a is an array of Comparable objects, then the existence of the method is assured because every class that implements the Comparable interface must supply the method.
NOTE: You would expect that the sort method in the Arrays class is defined to accept a Comparable array so that the compiler can complain if anyone ever calls sort with an array whose element type doesn’t implement the Comparable interface. Sadly, that is not the case. Instead, the sort method accepts an Object array and uses a clumsy cast:
If a[i] does not belong to a class that implements the Comparable interface, then the virtual machine throws an exception.
NOTE: According to the language standard: “The implementor must ensure sgn(x.compareTo(y)) = –sgn(y.compareTo(x)) for all x and y. (This implies that x.compareTo(y) must throw an exception if y.compareTo(x) throws an exception.)” Here, “sgn” is the sign of a number: sgn(n) is –1 if n is negative, 0 if n equals 0, and 1 if n is positive. In plain English, if you flip the parameters of compareTo, the sign (but not necessarily the actual value) of the result must also flip.
As with the equals method, problems can arise when inheritance comes into play. Because Manager extends Employee, it implements Comparable<Employee> and not Comparable< Manager>. If Manager chooses to override compareTo, it must be prepared to compare managers to employees. It can’t simply cast the employee to a manager:
That violates the “antisymmetry” rule. If x is an Employee and y is a Manager, then the call x.compareTo(y) doesn’t throw an exception—it simply compares x and y as employees. But the reverse, y.compareTo(x), throws a Class CastException.
If subclasses have different notions of comparison, then you should outlaw comparison of objects that belong to different classes. Each compareTo method should start out with the test
If there is a common algorithm for comparing subclass objects, simply provide a single compareTo method in the superclass and declare it as final.
For example, suppose that you want managers to be better than regular employees, regardless of the salary. What about other subclasses such as Executive and Secretary? If you need to establish a pecking order, supply a method such as rank in the Employee class. Have each subclass override rank, and implement a single compareTo method that takes the rank values into account.
Properties of Interfaces
Interfaces are not classes. In particular, you can never use the new operator to instantiate an interface:
However, even though you can’t construct interface objects, you can still declare interface variables.
An interface variable must refer to an object of a class that implements the interface:
Next, just as you use instanceof to check whether an object is of a specific class, you canuse instanceof to check whether an object implements an interface:
Just as you can build hierarchies of classes, you can extend interfaces. This allows for multiple chains of interfaces that go from a greater degree of generality to a greater degree of specialization. For example, suppose you had an interface called Moveable. public interface MoveableThen, you could imagine an interface called Powered that extends it:
Although you cannot put instance fields or static methods in an interface, you can supply constants in them. For example:
Just as methods in an interface are automatically public, fields are always public static final.
NOTE: It is legal to tag interface methods as public, and fields as public static final. Some programmers do that, either out of habit or for greater clarity. However, the Java Language Specification recommends that the redundant keywords not be supplied, and we follow that recommendation.
Some interfaces define just constants and no methods. For example, the standardlibrary contains an interface SwingConstants that defines constants NORTH, SOUTH, HORIZONTAL, and so on. Any class that chooses to implement the SwingConstants interface automatically inherits these constants. Its methods can simply refer to NORTH rather than the more cumbersome Swing Constants .NORTH. However, this use of interfaces seems rather degenerate, and we do not recommend it.
While each class can have only one superclass, classes can implement multiple interfaces. This gives you the maximum amount of flexibility in defining a class’s behavior. For example, the Java programming language has an important interface built into it, called Cloneable. (We discuss this interface in detail in the next section.) If your class implements Cloneable, the clone method in the Object class will make an exact copy of your class’s objects. Suppose, therefore, you want cloneability and comparability. Then you simply implement both interfaces.
Use commas to separate the interfaces that describe the characteristics that you want to supply.
Interfaces and Abstract Classes
If you read the section about abstract classes in Chapter 5, you may wonder why the designers of the Java programming language bothered with introducing the concept of interfaces. Why can’t Comparable simply be an abstract class:
The Employee class would then simply extend this abstract class and supply the compareTo method:
There is, unfortunately, a major problem with using an abstract base class to express a generic property. A class can only extend a single class. Suppose that the Employee class already extends a different class, say, Person. Then it can’t extend a second class.
But each class can implement as many interfaces as it likes:
Other programming languages, in particular C++, allow a class to have more than one superclass. This feature is called multiple inheritance. The designers of Java chose not to support multiple inheritance, because it makes the language either very complex (as in C++) or less efficient (as in Eiffel).
Instead, interfaces afford most of the benefits of multiple inheritance while avoiding the complexities and inefficiencies.
C++ NOTE: C++ has multiple inheritance and all the complications that come with it, such as virtual base classes, dominance rules, and transverse pointer casts. Few C++ programmers use multiple inheritance, and some say it should never be used. Other programmers recommend using multiple inheritance only for “mix in” style inheritance. In the mix-in style, a primary base class describes the parent object, and additional base classes (the so-called mix-ins) may supply auxiliary characteristics. That style is similar to a Java class with a single base class and additional interfaces. However, in C++, mix-ins can add default behavior, whereas Java interfaces cannot.
Core Java Related Interview Questions
|J2EE Interview Questions||Core Java Interview Questions|
|JDBC Interview Questions||JSP Interview Questions|
|Android Interview Questions||JavaServer Faces (JSF) Interview Questions|
|Java collections framework Interview Questions||Java 8 Interview Questions|
|Java Collections Interview Questions||Java Exception Handling Interview Questions|
|Java Concurrency Interview Questions||Java Serialization Interview Questions|
|Java Programmer Interview Questions||Java Inheritance Interview Questions|
|Java IO Interview Questions||Object Oriented Programming in PHP Interview Questions|
Core Java Tutorial
An Introduction To Java
The Java Programming Environment
Fundamental Programming Structures In Java
Objects And Classes
Interfaces And Inner Classes
User Interface Components With Swing
Deploying Applications And Applets
Exceptions, Logging, Assertions, And Debugging
All rights reserved © 2020 Wisdom IT Services India Pvt. Ltd
Wisdomjobs.com is one of the best job search sites in India.