Chapter 3 ■ Java Class Design

Essentials of OOP

To get a sense of the world of object-oriented programming, take a mental stroll around the television department of your local consumer electronics retailer. A television is an abstraction that offers certain functionality through the

proper interface (a TV remote). As a viewer, you need not understand how the TV works; the TV abstracts all the finergrain details of its operation from the viewer (abstraction). A television object encapsulates properties of the television (such as brightness, channel number, and volume) and associated behavior to control these properties in a single entity (encapsulation). In other words, the access to these properties is restricted to the associated operations. There are different types of televisions, such as CRT television, LED television, and LCD television; they belong to a single family forming an inheritance hierarchy. Although all types of televisions support “display” functionality, the internal technology enabling the display of content may differ (polymorphism).

With this television analogy in mind and with the help of the programming example introduced in the next section, let’s review the essential OOP concepts.

FunPaint Application: An Example

Let’s assume that you are implementing a simple drawing program for children called FunPaint (Figure 3-1). Users can drag and drop basic shapes like circles and squares, color them, and create drawings using those shapes.

Figure 3-1.  A children’s drawing application implemented using OOP concepts

We’ll use this example throughout this chapter to illustrate how OOP concepts can be used effectively for real-world programming and problem solving. For now, assume that the shapes such as Circle and Square are implemented as classes. A user can click on the circle icon and draw a circle in the drawing pane. With a circle, you need to remember associated information like center of the circle, radius of the circle, etc. To enable the user to color a circle, you need to calculate its area. Next you’ll look at how OOP concepts can be used to implement FunPaint functionality.

Foundations of OOP

Object orientation is built on the foundations of encapsulation, abstraction, inheritance, and polymorphism. The following sections refresh your understanding of each of these four concepts.

46

Chapter 3 ■ Java Class Design

Abstraction

The Latin root of abstraction means “taking away”—you take away everything except the specific aspect you wish to focus on. In other words, abstraction means hiding lower-level details and exposing only the essential and relevant details to the users.

For example, in order to drive a car, it is sufficient for a driver to have an essential repertoire of skills enabling her to interface with the car’s steering, gear shifting, dashboard, braking, and accelerator systems. For the driver, it is

superfluous to know the internal implementation details, such as how fuel is injected into the combustion chamber or how batteries are charged indirectly by the engine. The driver as such is concerned only about using the car and not about how the car works and provides functionality to the driver. In other words, a car abstracts the internal details and exposes to the driver only those details that are relevant to the interaction of the driver with the car.

In the FunPaint example, you define operations such as draw() and fillColor(). The user of the class Circle does not need to know how the class is drawing a circle or filling the circle with a specific color. In other words, you are abstracting the details of the class by hiding the implementation details.

Encapsulation

Structured programming decomposes the program’s functionality into various procedures (functions), without much concern about the data each procedure can work with. Functions are free to operate and modify the (usually global and unprotected) data.

In OOP, data and functions operating on that data are combined together to form a single unit, which is referred to as a class. The term encapsulation refers to combining data and associated functions as a single unit. For example, in the Circle class, radius and center are defined as private fields. Now you can adduce methods draw() and fillColor() along with fields radius and center, since the fields and methods are closely related to each other. All the data (fields) required for the methods in the class are available inside the class itself. In other words, the class encapsulates its fields and methods together.

encapsulation combines data (fields) and logically-related operations (methods). abstraction hides internal implementation level details and exposes only the relevant details of the class to the users. abstraction is achieved through encapsulation.

Inheritance

Inheritance is a reusability mechanism in object-oriented programming in which the common properties of various objects are exploited to form relationships with each other. The abstract and common properties are provided in the superclass, which is available to the more specialized subclasses. For example, a color printer and a black-and-white printer are kinds of a printer (single inheritance); an all-in-one printer is a printer, scanner, and photocopier (multiple inheritance). It should be noted that Java does not support multiple inheritance but does support multiple-interface inheritance (discussed in detail in Chapters 4 and 5).

When we say that a class B is inherited from another class A, then class B is referred to as a derived class

(or subclass) and class A is called as a base class (or superclass). By inheritance, the derived class receives the behavior of the base class, such that all the visible member methods and variables of the base class are available in the derived class. Apart from the inherited behavior, the derived class specializes its behavior by adding to or overriding base class behavior.

In FunPaint, the user can draw different shapes. Though the shapes are different, all shapes support similar functionality—for instance, color-filling and finding the area of the shape. Since these methods are common to all the shape classes, you can have a base class called Shape and declare these methods in this class. Other classes such as Circle and Triangle inherit from Shape and implement their specialized behavior.

47