The output from the program is shown here:

Inside Area for Rectangle.

Area is 45
Inside Area for Triangle.
Area is 40
Area for Figure is undefined.
Area is 0

Through the dual mechanisms of inheritance and run-time

polymorphism, it is possible to define one consistent interface that is used
by several different, yet related, types of objects. In this case, if an object
is derived from Figure, then its area can be obtained by calling area( ).
The interface to this operation is the same no matter what type of figure is
being used.

Using Abstract Classes

There are situations in which you will want to define a superclass that
declares the structure of a given abstraction without providing a complete
implementation of every method. That is, sometimes you will want to
create a superclass that only defines a generalized form that will be shared
by all of its subclasses, leaving it to each subclass to fill in the details.
Such a class determines the nature of the methods that the subclasses must
implement. One way this situation can occur is when a superclass is
unable to create a meaningful implementation for a method. This is the
case with the class Figure used in the preceding example. The definition
of area( ) is simply a placeholder. It will not compute and display the area
of any type of object.
As you will see as you create your own class libraries, it is not
uncommon for a method to have no meaningful definition in the context of
its superclass. You can handle this situation two ways. One way, as shown
in the previous example, is to simply have it report a warning message.
While this approach can be useful in certain situations—such as
debugging—it is not usually appropriate. You may have methods that must
be overridden by the subclass in order for the subclass to have any
meaning. Consider the class Triangle. It has no meaning if area( ) is not
defined. In this case, you want some way to ensure that a subclass does,
indeed, override all necessary methods. Java’s solution to this problem is
the abstract method.
You can require that certain methods be overridden by subclasses by
specifying the abstract type modifier. These methods are sometimes
referred to as subclasser responsibility because they have no
implementation specified in the superclass. Thus, a subclass must override
them—it cannot simply use the version defined in the superclass. To
declare an abstract method, use this general form:
abstract type name(parameter-list);
As you can see, no method body is present.
Any class that contains one or more abstract methods must also be
declared abstract. To declare a class abstract, you simply use the abstract
keyword in front of the class keyword at the beginning of the class
declaration. There can be no objects of an abstract class. That is, an
abstract class cannot be directly instantiated with the new operator. Such
objects would be useless, because an abstract class is not fully defined.
Also, you cannot declare abstract constructors, or abstract static methods.
Any subclass of an abstract class must either implement all of the abstract
methods in the superclass, or be declared abstract itself.
 Here is a simple example of a class with an abstract method, followed
by a class which implements that method:

Notice that no objects of class A are declared in the program. As

mentioned, it is not possible to instantiate an abstract class. One other
point: class A implements a concrete method called callmetoo( ). This is
perfectly acceptable. Abstract classes can include as much implementation
as they see fit.
Although abstract classes cannot be used to instantiate objects, they can
be used to create object references, because Java’s approach to run-time
polymorphism is implemented through the use of superclass references.
Thus, it must be possible to create a reference to an abstract class so that it
can be used to point to a subclass object. You will see this feature put to
use in the next example.
 Using an abstract class, you can improve the Figure class shown
earlier. Since there is no meaningful concept of area for an undefined two-
dimensional figure, the following version of the program declares area( )
as abstract inside Figure. This, of course, means that all classes derived
from Figure must override area( ).
 As the comment inside main( ) indicates, it is no longer possible to
declare objects of type Figure, since it is now abstract. And, all subclasses
of Figure must override area( ). To prove this to yourself, try creating a
subclass that does not override area( ). You will receive a compile-time
error.
Although it is not possible to create an object of type Figure, you can
create a reference variable of type Figure. The variable figref is declared
as a reference to Figure, which means that it can be used to refer to an
object of any class derived from Figure. As explained, it is through
superclass reference variables that overridden methods are resolved at run
time.

Using final with Inheritance

The keyword final has three uses. First, it can be used to create the
equivalent of a named constant. This use was described in the preceding
chapter. The other two uses of final apply to inheritance. Both are
examined here.

Using final to Prevent Overriding

While method overriding is one of Java’s most powerful features, there
will be times when you will want to prevent it from occurring. To disallow
a method from being overridden, specify final as a modifier at the start of
its declaration. Methods declared as final cannot be overridden. The
following fragment illustrates final: