2.1 Concepts of OOP

As you know, all computer programs include two elements: code and data. Conceptually, a program can be organized based on code and data. That is, some programs are written around “what is happening” and others are written around “who is being affected”. These are the two examples that show how a program is constructed. The first way is called the process-oriented model(面向過(guò)程模式).

This approach characterizes a program as a series of linear steps (that is, code). The process-oriented model can be viewed of as series of linear steps (that is, code). In the process-oriented model code is acted on data. C is paradigm for using this model. However problems appear as program grows larger and more complex.

To manage increasing complexity(復(fù)雜性), the second approach was invented. We called it called object-oriented programming(面向?qū)ο缶幊?. This model is described as data controlling access to code. As you will know, by switching the controlling entity to data, you can achieve several organization benefits.

The following problem is that how to obtain object. The same types of entity have the same properties. So we can extract those same features from real-entities. This approach is called abstraction.

Abstraction: Abstraction is the presentation of simple concept (or object) to the external world. Abstraction concept is to describe a set of similar concrete entities. It focuses on the essential, inherent aspects of an entity and ignoring its accidental properties. The concept is usually used during analysis: deciding only with application-domain concepts, not making design and implementation decisions.

Two popular abstractions: procedure abstraction and data abstraction. Procedure abstraction is to decompose problem to many simple sub-works. Data abstraction is to collect essential elements composing to a compound data. These two abstractions have the same objective: reusable and replaceable. Figure 2.1 shows an example of data abstraction to abstract doors as a data structure with essential properties.

Hierarchical classification is used to manage abstraction. This allows you to layer the semantics of complex systems, breaking them into more manageable pieces. From the outside, the car is a single object. Once inside, you see that the car consists of several subsystems: steering, brakes, sound system, seat belts, heating, cellular phone, and so on. In turn, each of these subsystems is made up of more specialized units. For instance, the sound system consists of a radio, a CD player, and /or tape player. The point is that you manage the complexity of the car (or any other complex system) through the use of hierarchical abstraction.

2.1.1 Class

A class is a construct that is used as a blueprint to create instances of itself. For example: There may be thousands of other bicycles in existence, all of the same make and model. Each bicycle was built from the same set of blueprints and therefore contains the same components. In object-oriented terms, we say that your bicycle is an instance of the class of objects known as bicycles. A class also is the blueprint from which individual objects are created.

2.1.2 Object

In everyday life, an object is anything that is identifiably a single material item. An object can be a car, a house, a book, a document, or a paycheck. For our purposes, we’re going to extend that concept a bit and think of an object as anything that is a single item that you might want to represent in a program. We’ll therefore also include living “objects”， such as a person, an employee, or a customer, as well as more abstract “objects”， such as a company, a database, or a country.

2.1.3 Encapsulation

Encapsulation is the mechanism that binds together code and the data it manipulates, and keeps both safe from outside interference and misuse.

Encapsulation allows an object to separate its interface from its implementation. The data and the implementation code for the object are hidden behind its interface. So encapsulation hides internal implementation details from users. The power of encapsulated code is that everyone knows how to access it and thus can use it regardless of the implementation details and without fear of unexpected side effects.

In Java the basis of encapsulation is the class. A class defines the structure and behavior (data and code) that will be shared by a set of objects. Each object of a given class contains the structure and behavior defined by the class, as if it were stamped out by a mold in the shape of the class. For this reason, objects are sometimes referred to as instance of class. Thus, a class is a logical construct; an object has physical reality.

When you create a class, you will specify the code and data that constitute that class. Collectively, these elements are called members of the class. Specifically the code that operates on that data is referred to as member variables or instance variables. The code that operates on that data is referred to as member methods or just methods. (If you are familiar with C/C++, it may help to know that what a Java programmer calls a method a C/C++ programmer calls a function.) In properly written Java programs, the methods define how the member variables can be used. This means that the behavior and interface of a class are defined by the methods that operate its instance data.

2.1.4 Inheritance

In object-oriented programming (OOP), inheritance is a way to compartmentalize and reuse code by creating collections of attributes and behaviors called objects which can be based on previously created objects. In classical inheritance where objects are defined by classes, classes can inherit other classes. The new classes, known as subclasses (or derived classes), inherit attributes and behavior (i.e. previously coded algorithms) of the pre-existing classes, which are referred to as superclasses, ancestor classes or base classes. The inheritance relationships of classes give rise to a hierarchy. In prototype-based programming, objects can be defined directly from other objects without the need to define any classes, in which case this feature is called differential inheritance.The inheritance concept was invented in 1967 for Simula.

Without the use of hierarchies, each object would need to define all of its characteristics explicitly. However, by use of inheritance, an object need only define those qualities that make it unique within its class. It can inherit its general attributes from its parent. Thus, it is the inheritance mechanism that makes it possible for one object to be a specific instance of a more general case. Let’s take a closer look at this process.

Most people naturally view the world as made up of objects that are related to each other in hierarchical way, such as animals, mammals, and dogs. If you wanted to describe animals in an abstract way, you would say they have some attributes, such as size intelligence, and type of skeletal system. Animals also have certain behavioral aspects; they eat, breathe, and sleep. This description of attributes and behavior is the class definition for animals.

2.1.5 Polymorphism

Polymorphism (from the Greek, meaning “many forms”) is the ability to create a variable, a function, or an object that has more than one form. In Java, polymorphism is the ability of objects to react differently when presented with different information, known as parameters. In a functional programming language, it is the only way to complete two different tasks is to have two functions with different names.