The JavaTM Tutorial

| Start of Tutorial > Start of Trail > Start of Lesson | Search Feedback Form

Trail: Learning the Java Language
Lesson: Classes, Interfaces, and Packages

## Writing Abstract Classes and Methods

> Sometimes, a class that you define represents an abstract concept and, as such, should not be instantiated. Take, for example, food in the real world. Have you ever seen an instance of food? No. What you see instead are instances of carrot, apple, and (our favorite) chocolate. Food represents the abstract concept of things that we all can eat. It doesn't make sense for an instance of food to exist.

> Similarly in object-oriented programming, you may want to model an abstract concept without being able to create an instance of it. For example, the `Number` class in the `java.lang` package represents the abstract concept of numbers. It makes sense to model numbers in a program, but it doesn't make sense to create a generic number object. Instead, the `Number` class makes sense only as a superclass to classes like `Integer` and `Float`, both of which implement specific kinds of numbers. A class such as `Number`, which represents an abstract concept and should not be instantiated, is called an abstract class. An abstract class is a class that can only be subclassed-- it cannot be instantiated.

> To declare that your class is an abstract class, use the keyword `abstract` before the `class` keyword in your class declaration:

> >     abstract class Number {
> >         . . .
> >     }

> If you attempt to instantiate an abstract class, the compiler displays an error similar to the following and refuses to compile your program:

> >     AbstractTest.java:6: class AbstractTest is an abstract class.
> >     It can't be instantiated.
> >             new AbstractTest();
> >             ^
> >     1 error

### Abstract Methods

> An abstract class may contain abstract methods, that is, methods with no implementation. In this way, an abstract class can define a complete programming interface, thereby providing its subclasses with the method declarations for all of the methods necessary to implement that programming interface. However, the abstract class can leave some or all of the implementation details of those methods up to its subclasses.

> Let's look at an example of when you might want to create an abstract class with an abstract method in it. In an object-oriented drawing application, you can draw circles, rectangles, lines, Bezier curvess, and so on. Each of these graphic objects share certain states (position, bounding box) and behavior (move, resize, draw). You can take advantage of these similarities and declare them all to inherit from the same parent object--`GraphicObject`.

> However, the graphic objects are also substantially different in many ways: drawing a circle is quite different from drawing a rectangle. The graphics objects cannot share these types of states or behavior. On the other hand, all `GraphicObject`s must know how to draw themselves; they just differ in how they are drawn. This is a perfect situation for an abstract superclass.

> First you would declare an abstract class, `GraphicObject`, to provide member variables and methods that were wholly shared by all subclasses, such as the current position and the `moveTo` method. `GraphicObject` also declares abstract methods for methods, such as `draw`, that need to be implemented by all subclasses, but are implemented in entirely different ways (no default implementation in the superclass makes sense). The `GraphicObject` class would look something like this:

> >     abstract class GraphicObject {
> >         int x, y;
> >         . . .
> >         void moveTo(int newX, int newY) {
> >             . . .
> >         }
> >         abstract void draw();
> >     }

> Each non-abstract subclass of `GraphicObject`, such as `Circle` and `Rectangle`, would have to provide an implementation for the `draw` method.

> >     class Circle extends GraphicObject {
> >         void draw() {
> >             . . .
> >         }
> >     }
> >     class Rectangle extends GraphicObject {
> >         void draw() {
> >             . . .
> >         }
> >     }

> An abstract class is not required to have an abstract method in it. But any class that has an abstract method in it or that does not provide an implementation for any abstract methods declared in its superclasses must be declared as an abstract class.

| Start of Tutorial > Start of Trail > Start of Lesson | Search Feedback Form