Java classes should be designed to enhance their reusability and
flexibility. Coding to an object type rather than an implementation
by using interfaces or abstract classes can help us achieve both
flexibility and reusability.

What Is an Abstract Class?
Everything in Java is an object, so to write Java programs we
need to define classes. A Java class in turn defines the type and the
available methods for that type. It also provides the implementation
of the methods that it defines. This kind of class is called a
concrete class. An abstract class, defined in section 8.1.1.1 of the
Java Language Specification (JLS), defines the type and the available
methods but is not required to implement any of the methods that it
defines.

An abstract class is denoted by the keyword abstract in the
class declaration and usually contains one or more abstract methods.
An abstract method declaration defines the method name, number and
type of parameters, return type, and throws clause, but does not have
an implementation. In the declaration an abstract method is denoted
by the abstract keyword, as is the case with method f1 in the class
Base defined earlier.

Why design with an abstract class instead of a concrete
class? Using an abstract class allows you to define the interface of
a type and still provide method implementations without having to
implement the entire set of methods. The term interface is used here
to mean the publicly accessible functions on the class, not the Java
interface, which we'll look at next. The abstract class represents a
type at a very generic level. Although operations can be defined for
the type, the abstract class can't provide all the functionality
without becoming too specific.

An abstract class is incomplete and relies on its subclasses
to complete the implementation. In the following code sample the
class X inherits from the class Base by extending it. The class Base
is considered the superclass of class X. The class X is considered
the subclass (or subtype) of class Base. For X to avoid being
declared abstract, it must implement the abstract method f1 defined
in the class Base. The definition of class X is listed below:

What Is an Interface?
A Java interface defines a type and the available methods for
that type. It does not, and, in fact, cannot provide an
implementation for any of the methods it defines. An interface is
defined in section 9 of the Java Language Specification.

The interface and all the methods on it are automatically
considered abstract and do not require the abstract keyword.

To be of any use a Java interface must be implemented by a
Java class. In the following code sample, the class Basic implements
the interface iBasicType. The class Basic must provide an
implementation for every method in the interface, otherwise it must
be declared an abstract class.

A class implementing an interface can also declare additional
methods that aren't part of the interface. This is shown in the Basic
class definition by defining method f2, which isn't part of the
iBasicType interface.

Some important points to remember:

An interface cannot be instantiated.

An interface has no implementation.

All the methods on an interface are considered public and abstract.

All the fields on an interface are considered public, static,
and final.

An interface can extend other interfaces.

A class can implement one or more interfaces.

The Power of Dealing with Types
Java is a strongly typed language, so every object in Java
has a type. The type associated with any particular object is its
class name. For example, when the class Customer is instantiated, the
object is said to be of the type Customer. Each instance of an object
may have a different state, but all objects of the same type have the
same set of methods because they're created from the same class.
Abstract classes and interfaces give us more flexibility in our
programs because they allow us to look at an object as a different
type instead of just using its class name.

For example, the object Y, shown in Figure 1, can be created
from the following line of code:

Y myYObj = new Y();

The variable myYObj contains an object reference of type Y
that points to a Y object in memory after this code is executed.
Through the Y object reference all the methods defined on the Y
object and any class it extends can be invoked. Since Y extends the
class X, they're related and we can treat the subclass Y as if it
were actually any one of its superclasses, in this case X or Base;
e.g., the following code is completely valid:

X myXObj = myYObj;

The variable myXObj contains an object reference of type X,
but the reference points to a Y object in memory after this line of
code is executed. This allows us to look at the Y object as if it
were really of type X. The compiler can safely place references to
subclasses into a variable that's declared to be a superclass of that
subclass, since the subclass is guaranteed to contain all the methods
and variables that can be called on the superclass. Simply, Y extends
X, so the compiler is assured that any method that can be called on X
can also be called on Y. However, the reverse is not guaranteed to be
true so the following code is not valid:

Y anotherYObj = new X(); // This is not valid

Dealing with a subclass object as if it were really one of
its superclasses is called upcasting or narrowing. It's important to
understand that the object reference, which points to an object in
memory, does not determine the type of the object that gets the
request to invoke a method, nor does it change the type of the object
that was instantiated. The object reference does, however, affect how
the object it points to can be operated on. The object reference
defines the type through which the calling program sees the object in
memory. You can think of the X object reference as a filter that
allows only calls to methods that are defined in the X class and any
class it extends. Looking at the class diagram in Figure 1, we can
call the f1, f2, and f3 methods through the X object reference. But
we couldn't call the f4 method even though this is a valid method on
the Y object, because it's not defined by the class X or any of its
superclasses.

When we call methods through the X object reference using the
myXObj variable, we're actually invoking methods in the object that
the reference points to in memory. In this case it's a Y object
instance.

myXObj.f1(); // returns "Y.f1()"
myXObj.f3(); // returns "X.f3()"

These method calls give the results shown in the comment
sections based on the following definition of the Y class:

Notice that the implementation of the f1 method on the Y
class is run even though we're using an X object reference. In this
example, the Y class does not define its own f3 method, so the
implementation of the f3 method on the X class is executed.

It's possible to point an object reference to an object that
is its subclass because Java performs dynamic binding. Objects
communicate by sending messages to each other through references.
This is basically a means of calling methods on the object. Dynamic
binding allows messages to be sent to an object without knowing the
exact type of the object that the message will be sent to when the
code is written. When the code is executed and a method is invoked,
the JVM determines which method is actually executed based on which
object is being pointed to by the object reference at runtime.

The message to execute a particular method cannot be sent to
just any object. Java is a strongly typed language so the compiler
makes sure the assignment is type-safe. A variable has a type that
never changes, so the myXObj variable will always hold an X object
reference. When the variable type is a reference type (arrays,
classes, and interfaces), it can point to different objects that are
related via inheritance or an interface. Specifically, a reference
variable can be assigned a reference to any object whose class is:

Of the same type as that of the reference variable declaration

A subtype of the type that the reference variable is declared to be
Or any object that implements:

The same interface that the reference variable is declared to be

An interface that is a subtype of the interface that the
reference variable is declared to be

An Example with an Interface

We can declare variables to have a type that is defined as an
abstract class or an interface even though they can't be
instantiated. Given the class hierarchy shown in Figure 1, a variable
can be declared as follows:

iBasicType myBasicObj;

The variable, myBasicObj, holds an object reference to the
interface iBasicType. We can instantiate objects that implement the
interface using the code sample below:

iBasicType myBasicObj = new Basic();

The variable, myBasicObj, holds an iBasicType reference that
points to a Basic object in memory. Since the class Y also implements
the interface iBasicType, the following code is also valid:

iBasicType anotherBasicObj = new Y();

By implementing an interface, the object is also declaring
that it is of that type. For example, the class Y can be said to be
of type Y, its class name, as well as of type iBasicType, since it
implements that interface.

Like the variable that holds an object reference to a class
type, an object reference to an interface type defines the way the
calling program sees the object in memory. So we can call the f1 and
f4 methods through the iBasicType object reference. But we could not
call the f2 method even though this is a valid method on both the
Basic and the Y object, because it's not defined by the interface
(see Figure 1).

Wrapping It Up

Hopefully, you'll begin to see the potential flexibility we
can design into our applications by coding to different types.
Applying this in a practical sense will be the focus of our next
article, until then, happy coding.

About Mike BarlottaBackground Information: Michael Barlotta is the Director of Technology at AEGIS.net Inc (www.AEGIS.net). Mike is a Sun Certified Java Programmer and is recognized as an expert on the Sybase application server EAServer (Jaguar CTS), mentoring clients and speaking at conferences on the topic. He is the author of several books including Taming Jaguar and Jaguar Development with PowerBuilder 7 (both by Manning Publications). Be sure to check out Mike’s Web site www.TamingJaguar.com.

Most organizations are awash today in data and IT systems, yet they're still struggling mightily to use these invaluable assets to meet the rising demand for new digital solutions and customer experiences that drive innovation and growth. What's lacking are potent and effective w...

On-premise or off, you have powerful tools available to maximize the value of your infrastructure and you demand more visibility and operational control. Fortunately, data center management tools keep a vigil on memory contestation, power, thermal consumption, server health, and ...

While a hybrid cloud can ease that transition, designing and deploy that hybrid cloud still offers challenges for organizations concerned about lack of available cloud skillsets within their organization. Managed service providers offer a unique opportunity to fill those gaps and...

Darktrace is the world's leading AI company for cyber security. Created by mathematicians from the University of Cambridge, Darktrace's Enterprise Immune System is the first non-consumer application of machine learning to work at scale, across all network types, from physical, vi...