Você está na página 1de 11

Object Oriented Basics

What is an Object?
If you are familiar with programming, you know that programming on a very basic level requires:
y y

Code - The part of the program that allows functionality. Sets of instructions that tell the program how to operate or what to do. Data - Where program and external information is stored. There are several data types such as integers, strings, float values and more. Data is called attributes in object oriented programming.

When writing code, the code is put into what is called procedures or functions. The classic difference between a procedure and a function is that a function returns a value when a procedure does not, however the terms function and procedure are sometimes used interchangeably. In the real world, an object includes such things as:
y y y

Table Chair Car

You get the idea. In the computer world, objects are simulated using code and data. The data stores the current and permanent states of the object, and the code makes the object perform its functions (also known as behavior). For example in the case of a car permanent object data would include:
y y y y y y

Make - The manufacturer of the car. Model Color Engine horsepower Transmission information Passenger capacity

There are many more. The current object state describes characteristics of the object that would change with time such as:
y y y y

Position or location Speed Fuel reserve Mileage

To make an object perform functions the following types of functions may be required:
y y y y y y y y

Start Turn off Accelerate Decelerate Turn number of degrees left Turn Number of degrees right Check fuel reserve Fill fuel tank

As you can see an object requires the above items and more to make it what it is. Therefore objects in the programming world consist of:
y y

Functions Data (or attributes)

Classes are used to implement objects. Classes are not objects themselves, but are used to create objects. An excellent comparison of classes and objects is to compare a class to a cookie cutter and the object is a cookie. Classes are templates for objects.

Object Classes
Hierarchy
Classes are used as templates for objects to define them. Classes are used in a hierarchial nature. This means that a class may have subclasses. For exampls a car might have the following subclasses:
y y y y y y y

Body Engine Tire (4 instances plus a spare) Transmission Seat(s) Door(s) Trunk

Each of these objects may also have a subclass. For example the engine would include carburator, pistons, cylinders, spark plugs and more. The object containing the subclasses is referred to as the parent class, also called the superclass. The object to subobject hierarchy is arranged from the less specific parent to the more specific subclass, also sometimes called the

child class. As you move down into the subclasses, information is more specific. This means that the superclass or parent class is the generalization of the subclass and the subclass is the specialization of the parent class.

Class Relationships
When classes use or contain subclasses, the following relationships outline the differences between the respective classes:
y

A-kind-of - The A-kind-of relationship is a classic relationship such as a sports car is a kind of car, or a Ford mustang is a kind of a car. This refers from the specific (type of car) to general (car) description. This is a general description of the subclass to parent class relationship. Part-of - This relationship is of the type described above where a car is composed of specific parts. This refers from the subclass to the parent or superclass. An engine is part of a car. Has-a - This is the inverse of the part-of relationship and refers from the parent or superclass to the subclass. A car has an engine. This concept is called aggregation or composition and is designated by a filled diamond in the Unified Modeling Language (UML).

Class Declaration and Sections


When a class is declared, there are three possible sections inside the class:
y y y

Public - Data and methods in this section are accessible outside the class. Protected - Data and methods in this section are accessible to this class and subclasses derived from this class or one of its subclasses. Private - Data and methods in this section are not accessible outside the class. Only functions in this class have access to private functions and data.

The friend construct allows private data and methods to be accessible to classes that are declared "friends" with the class the private data and methods are in. An example of class declarations with friend declarations in C++ is:
class Aclass { friend class Bclass; //Make Bclass a friend class friend int Zclass::ready(); //Make the ready() method in Zclass a friend private: int x, y; void funct1(int n) { x=n; } protected: int a, b; public:

int x1, y1; functa(int m) { if (m ) funct1(m); //although x cannot be changed externally, this function called from external sources can change it. } }

Inheritance Inheritance is applied in the a-kind-of class relationship. As in all parent child relationships, children (subclasses) inherit the characteristics of the parent class, also called the superclass. What this means is when a subclass is created from a parent class, it willinherit the functions and data that is defined in the parent class. What this means is that the same attributes and methods are available to the subclass. For instance the car class is:
class Car { attributes: float positionx float positiony float speed float direction float maxaccel = 50 methods: accelerate(float) turn(float) }

An example of a subclass being declared follows:


class parent_classA { int var1, b; setVariable(int n) { var1=n; } }; class sub_ClassA : parent_classA { setVariable(int n) { var1=b*n; } };

The class sub_classA is the subclass of the superclass or parent class parent_classA. In this case sub_classA inherited the integer variables var1 and b along with the

method setVariable(int) from the parent class parent_classA. It overrode the setVariable(int) method with a setVariable(int) method of its own. A derived class cannot access the private data of its parent unless specifically authorized by the parent. When the child class is created using a parent class, additional values and functions may be added to the subclass to make it more specific. For instance if the parent class is a car, the child class may be sports car. The sports car could have additional data describing it in more detail. In this case, although the parent car class has an engine, the sports car may have a more powerful engine definition. Therefore in the sports car class, the engine is defined again with different information. In the example above maxaccel=120 may be defined rather than the value of 50 for a standard car. This way the original car engine characteristics are overridden in favor of the more powerful engine. Multiple Inheritance A subclass may inherit from two or more parent classes. This does not refer to two parent classes where one is a parent to the other. This refers to two parent classes that are independent of each other. This capability does not apply to Java. Java uses interfaces to add some functionality in this area. Abstract Classes Abstract classes are used to define a basic class which may contain specific defined attributes and methods along with specific abstract methods which are not fully defined. These methods not fully defined must be fully defined in the child class. For example a goemetric figure may have a drawing method along with X and Y position information. The draw method would be defined in the abstract class for the geometric figure (the geometric class). The draw method would be fully defined in all subclasses which are the type of geometric figure such as circle or square. Therefore the subclass circle or square would define their own draw method which would override the draw method defined in the geometric class. Generic Types Generic types are the complement to abstract classes although they are not classes. They are merely a template used to create classes. They define the methods to be used in the class, but leave the data or attributes to be defined in the specific class. List types are used for this purpose. The methods such as appending or removing items from the list are provided, but the data is not since it will depend on the type of list.

Messages Messages are sent when an object calls another object method. There are three parts to the message:
y y y

Name of the object the message is sent to. Name of the method being called. Any required parameters which are variables or values being passed to the method.

An example of calling a method would be to first create an instance of the Car class (as in the above example) with the following line: car Car; Then call a method of the object car: car accelerate(20); This sends a message to the car object and calls the method. Virtual Functions and Polymorphism Methods are uniquely identified by:
y y

Name of method Parameter list

Polymorphism (many form) refers to an objects ability to become many different object forms. Polymorphism allows multiple methods (functions) to have the same name. The functions are uniquely identified by the parameter list used. For instance if there are two methods with the name "method1" and one of them requires two integer variables and the other requires one integer variable in the parameter list, if "method1(int 10)" is called, the function with the single integer on the parameter list is called. The difference in parameter list may be that parameters passed to the function are of a different type rather than quantity. One method may require a string variable while another requires a float variable. An example should help. In this example, the class "Shape" is defined in another file and has a getArea() method that is overridden by the Triangle and Rectangle classes. The getArea() methods in both Triangle and Rectangle share the same interface (The same number and type of parameters are passed which is none) although the methods

are different. When the printArea(Shape) method is called from main, the correct method for the correct object is called although the method is actually different from one object to another. This is one way polymorphism is applied.
import Shape; public Class Triangle extends Shape { int height, width; public int getArea() { return (int) ((height * width)/2); } } public Class Rectangle extends Shape { int height, width; public int getArea() { return height * width; } } public static void main(String[] args) { rect = new Rectangle; tri = new Triangle; printArea(rect); printArea(tri); } void printArea(Shape figure) { int x, y; System.out.println(figure.getArea()); }

Constructors and Destructors Constructors have the same name as the class they are defined in. They provide for automatic initialization of objects and parameters when the object is declared. Destructors are indicated with the tilde, ~, in front of them. They provide for automatic deallocation of resources used by the object. Constructor example:
class Aclass { friend class Bclass;

//Make Bclass a friend class

friend int Zclass::ready(); Zclass a friend private: int x, y; public: int a, b; Aclass() { x=0; y=0; a=0; b=0; } void funct1(int n) { x=n; }

//Make the ready() method in

functa(int m) { if (m ) funct1(m); //although x cannot be changed externally, this function called from external sources can change it. } }

Object Oriented Scope


In object oriented programming, methods and variables have various scope. Scope means that the method or variable may or may not be directly accessable to other objects or classes. Classes that do not have instances may be accessable to the system. Class Scope Class variables and class methods are associated with a class. An instance of the class (object) is not required to use these variables or metnods. Class methodc cannot access instance variables or metnods, only class variables and methods. Instance Scope Instance variables and instance methods are associated with a specific object. They can access class variables and methods. Private Scope

Private variables and private methods are only accessible to the object they are contained in. Protected Scope Protected variables and protected methods are accessible by the class they are in and inheriting classes (sub classes). Public Scope Public variables and public methods are accessible outside the object they are contained in. They are accessible to any other object. Encapsulation The process of providing a public interface to interact with the object while hiding other information inside the object. Java Variables and Scope There are three types of variable scope in Java.
y y y

Class variables - Applies to all instances of a class of objects. Instance variables - Define an objects attributes. Local variables - Are defined and used inside methods or other statement blocks such as a catch block. After the block or method is exited, the variables no longer exist. They must be declared and given values before use.

Unified Modeling Language


Unified modeling language (UML) references and diagrams are common when dealing with JAVA programming. UML is used to describe the relationship between objects. For instance, in the section about classes class relationships were described such that three possible object relationships are:
y

A-kind-of - The A-kind-of relationship is a classic relationship such as a sports car is a kind of car, or a Ford mustang is a kind of a car. This refers from the specific (type of car) to general (car) description. This is a general description of the subclass to parent class relationship. This relationship is shown with an arrow pointing from the sub class to the parent class. Part-of - This relationship is of the type described above where a car is composed of

specific parts. This refers from the subclass to the parent or superclass. An engine is part of a car. This relation in the reverse of the "Has-a" relationship, below. It is indicated using a solid diamond as described below. Has-a - This is the inverse of the part-of relationship and refers from the parent or superclass to the subclass. A car has an engine. This concept is called aggregation or composition and is designated by a filled diamond at the containing class in the Unified Modeling Language (UML).

Object Modeling
Objects are shown as boxes with up to three sections. The sections are:
y y y

Type of object (class name) Data members important enough to list. Member functions. This is also called the interface since it is a list of functions used to "interface" the object to the outside world.

Object Relationships In the drawing below, the class "airplane" "has-an" engine and wings which is an aggregation or composition relationship. The "jetfighter" and the "ultralight" class are "a-kind-of" the class "airplane". The aggregation relationship is shown with a solid diamond, and the "a kind of" relation is shown with an arrow. Of course, the jetfighter

and the ultralight class would use the keyword "extends" with the phrase "jetfighter extends airplane" when the class is declared to be a subclass of the airplane class. The engine and the wings class would be a part of the airplane class and be implemented inside the airplane class.