These tutorials will introduce you to Java programming language. You'll compile and run your Java application, using Sun's JDK. It's very easy to learn java programming skills, and in these parts, you'll learn how to write, compile, and run Java applications. Before you can develop corejava applications, you'll need to download the Java Development Kit (JDK).
PART-4
Interfaces
There is one thing in Java source code that is neither a class nor a member of a class. That's an interface. An interface defines methods
that a class implements. In other words it declares what certain classes do. However an interface itself does nothing. All the action at least,
happens inside classes. A class may implement one or more interfaces. This means that the class subscribes to the promises made by
those interfaces. Since an interface promises certain methods, a class implementing that interface will need to provide the methods specified
by the interface. The methods of an interface are abstract -- they have no bodies. Generally, a class implementing an interface will not only
match the method specifications of the interface, it will also provide bodies -- implementations -- for its methods.
For example, a ScoreCounter class might meet the contract specified by the Counting interface:
interface Counting
{
abstract void increment();
abstract int getValue();
}
So might a Stopwatch, although it might have a totally different internal representation. Both would have increment() and getValue()
methods, but the bodies of these methods might look quite different. For example, a ScoreCounter for a basketball game might implement
increment() so that it counts by 2 points each time, while a Stopwatch might call its own increment() method even if no one else does.
A class that implements a particular interface must declare this explicitly:
class ScoreCounter implements Counting {
....
}
If a class implements an interface, an instance of that class can also be treated as though its type were that interface. For example, it can be labeled
with a name whose declared type is that interface. For example, an instance of class ScoreCounter can be labeled with a name of type Counting. It will also
answer true when asked whether it's an instanceof that interface type: if myScoreCounter is a ScoreCounter, then myScoreCounter instanceof Counting is true.
Similarly, you can pass or return a ScoreCounter whenever a Counting is required by a method signature.
The generality of interfaces and the inclusion of multiple implementations within a single (interface) type is an extremely powerful feature. For example, you
can use a name of type Counting to label either an instance of ScoreCOunter or an instance of Stopwatch (and use its increment() and getValue() methods) without
even knowing which one you've got.