The CTDP Object Oriented Basics Guide

Object Oriented Basics

What is an Object?
If you are familiar with programming, you know that programming on a very basic level
requires:
• 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:
• 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:
• 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:
• Position or location
• Speed
• Fuel reserve
• Mileage
To make an object perform functions the following types of functions may be required:
• 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:
• 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 hierarchical
nature. This means that a class may have subclasses. For examples a car might have the
following subclasses:
• 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
carburetor, 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:
 • 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:
• 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 will inherit 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:
• 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:
• 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(); //Make the ready() method in
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;
}

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.
• Class variables - Applies to all instances of a class of objects.
• Instance variables - Define an object’s 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.

Object Data
Scope
• Local
• Global
Java Basic Data Types
Also called primitive types.
• Integers - All types are signed.
○ byte - 8 bits
○ short - 16 bits
○ Int - 32 bits
○ long - 64 bits
• Floating point numbers
○ float
○ double - For more precise real number calculations.
• Characters - char
• Boolean - boolean - True or false.

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:
• 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:
• 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.

Object Oriented Terms

• Attributes - Data describing an object. the attributes or characteristics of the object.
• Behavier - Defined by the methods the object contains.
• Classes - The implementation of an abstract data type defining attributes and methods.
With C++ this is used with pointers but with JAVA late binding is done automatically
when required.
• Constructor
• Destructor
• Early binding - The method used to implement an action is implemented at compile time.
Used with pointers and may not apply to JAVA.
• Encapsulation - The process of providing a public interface to interact with the object
while hiding other information inside the object.
• Friend - allows private data and methods to be accessible to classes that are declared
"friends" with the class the private data and methods are in.
• Function - A subroutine written to perform a specific task and return a value.
• Implementation - The implementation of objects is hidden in the object class. This means
that the data and functions that define the object are defined by the object's class.
• Instance - An instance of a class. An object.
• Instantiation - Creating an instance of a class which is an object.
• Late binding - The method used to implement an action is implemented at run time. The
virtual keyword is used to designate functions defined at run time. With C++ this is used
with pointers but with JAVA late binding is done automatically when required.
• Message - A request to an object to invoke one of its methods. Messages contain the
name of the method and the arguments required by the method.h
• Object - An instance of a class.
• Operator Overloading
• Polymorphism
• Procedure - A subroutine written to perform a specific task but not return a value.
• 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.
• Protected - Data and methods in this section are accessible to this class and subclasses
derived from this class or one of its subclasses.
• Public - Data and methods in this section are accessible outside the class.
• Virtual functions - Use of the keyword virtual in front of the function designates that it is
implemented at run time. Used with pointers and may not apply to JAVA.