CLASSES AND METHODS
IMPLEMENTING CLASS DIAGRAM IN
C++ AND JAVA
Classes encapsulation and Instantiation
2
Classes provide two very important capabilities:
Encapsulation - The purposeful hiding of
information, thereby reducing the amount of details
that need to be remembered/communicated among
programmers.
Instantiation - The ability to create multiple
instances of an abstraction.
Classes Behavior and State
3
A class can also be viewed as a combination of
behavior and state.
Behavior: The actions that an instance can perform in
response to a request. Implemented by methods.
State: The data that an object must maintain in order
to successfully complete its behavior. Stored in instance
variables (also known as data members, or data
fields).
State - Instance Variables
4
We have been using the term instance to mean a
representative or an example of a class.
We will use the term instance variable to represent the
state, or data values maintained internal to a class.
We can record information about the instance variable on
the back side of a CRC card, since it is internal to a class.
Clients can see the front of the card, implementers can
see the back of the card.
Example – Bank account
5
This is the front (public face) of a typical CRC
card.
Account
getBalance
getInterest
Deposit money
Withdraw money
Bank account - Data Areas
6
The back of the card can be used to record information
about the internal state of the card
Account - Implementation Information
double getBalance {The amount of money in the account};
double getInterest {The interest earned};
Deposit {Put some money into a bank account}
Withdraw {Remove some money from an account};
.
Revision of Account
7
We have refined the behavior by providing explicit
function names and argument types.
Account
double getBalance();
double getInterest();
deposit(double amount);
withdraw(double amount);
Varieties of Classes
8
There are four common forms of classes:
Data managers
Data sinks or sources
View or observer classes
Facilitator or helper classes
Varieties of Classes
9
Data Managers
Classes whose principal responsibility is to maintain
data values.
Account - maintains balance and account number
information.
Data Sinks and Sources
Objects that interface to data generators or
consumers, but do not hold data values themselves.
Input/Output Stream objects - files I/O devices
Varieties of Classes
10
View or Observer Classes
Classes that provide the graphical display of an object,
but are not the object themselves.
Tasks involved in viewing are different from tasks
involved in data manipulation
A single object might have many different forms of
views.
Facilitator and Helper Classes
Classes that maintain little or no state information, but
assist in the execution of complex tasks. An example
might be a painting assistant (Pen, Canvas, Edit box)
for a graphics output device.
Implementing Class State
Properties are sometimes called variables or states.
To declare a property use the following syntax:
["public" | "private" | "protected" ] [
"final/const" ][ "static" ] data_type
var_name
The access modifiers public, private and protected
determines the visibility or accessibility of the data
from other objects.
Implementing Class State
public means visible everywhere (global).
private indicates accessible only to this class and
nested classes.
protected means visible to this class or inherited (ie.
extended) classes only.
final in Java or const in C++ indicates continuous
retention and unchangeable after initial assignment
(i.e. it is a constant).
Implementing Class State
The data_type is one of the primitive types namely
int, float, double, char or reference type such as
String and can be optionally initialized
In C++, you do not have to provide access specifier
for each data, you use the specifier followed by a
list of the data members under that specifier:
class Employee {
private:
int idNum;
double salary;
: }
Implementing Class State
However in Java, you are required to state the
access level for each data member. For example:
public class Employee
{
private String name;
private int id;
private double gSalary;
:
}
Implementing Class Methods
Class behaviour are represented in Java by
methods also known as member functions in C++.
A method function provides an interface to the
private member data of the class.
Just like data members, you have to provide access
level to a method using syntax:
[ "public" | "private" | "protected" ] [ "final" ][
"static" | "abstract" | "native" ] return_data_type
method_name "(" parameter_list ")" "{" // some
defining actions "}"
Implementing Class Methods
static methods are shared by all members and exist
for all runtime. Static methods can be referenced
without creating an instance of the class.
abstract (Java) methods must be redefined on
inheritance.
native (Java) methods are written in C but
accessible from Java.
The return_data_type defines the type of value that
the calling routine receives from the object.
Implementing Class Methods
The parameter_list can contain from zero to many
entries of datatype varName pairs. Entries are
separated by commas.
In Java parameters are passed by value, thus
upholding the encapsulation principle by not
allowing unexpected changes or side effects.
Object references (such as arrays) can also be
passed.
Implementing Class Methods
Generally Java and C++ provides three types of
methods :
Constructor;
Accessor;
Mutator
Constructors
Construction of an object involves two actions:
Allocation of memory
Initialization of the object variables
Though constructors are optional their primary role of
a class constructor is to initialize each of the data
members of the class with values.
Constructors come into action when the object are
created.
Constructors
Public class Box
public Box()
{
length=0; width=0; height=0;
}
public Box(int l,int w,int h) {
length=l; width=w; height=h;
}
Constructors
Therefore a constructor:
Is a public member function
It is called when a new object is created (instantiated).
Initializes data members in a class.
Has same name as class
Does not have return type
One can use several constructors
Non-Parameterized constructor
Parameterize constructor
Overloaded constructor
Parameterized constructor
The constructors discussed earlier have no parameters.
For example the constructor employee has two default
arguments idNum= 120 and salary =100.0
Employee()
{
int idNum = 120;
double salary=100.0;
}
You can define a constructor that receives message from
an external and assigns the value to the member data
such as:
Parameterized constructor
class Sale {
private:
float taxRate;
float total;
Public:
Sale (float rate) {
taxRate =rate
} …};
The constructor purpose is to establish the tax rate
which may be used to compute the total sale
Overloaded constructor
Two or more constructors can share the same name as
long as their parameter list is different. The example
below demonstrates constructor overloading:
Public:
Sale ( ) {
taxRate = 0.16;
}
Sale (float rate) {
taxRate =rate
}
…};
Accessor Methods
Accessor (or observer) methods read property (ie.
field variable) values and returns the to the caller.
They are conventionally named getX() or whatever
the property is called.
For example:
public String getName()
{
return name;
}
Mutator methods
Mutator (or transformer) methods set property
values and are often named setFX() etc.
Mutators can be used modify state on behalf of the
caller method.
public void setName(String newName)
{
name = newName;
}
Once modification has been done, we can use getX
Mutator and Accessor methods
It is good programming practice to make each
property in a class private and include accessor and
mutator methods for them.
The exceptions to writing accessor/mutator methods
for each property is for those that are used only
within the class itself or for properties that are set in
more complex ways.
Other methods
Helper methods are those routines that are useful
within the class methods but not outside the class.
They can help in code modularization. Normally
they are assigned private access to restrict use.
Recursive methods are methods that are defined in
terms of themselves.
An example is factorials where n factorial is the
product of positive integer n and all the products
before it down to one.
Implementing Class in Java
public class Person
{
private String name;
public Person()//default constructor
{
name = "No name yet.";
}
public Person(String initialName)
{
name = initialName;
}
Implementing Class in Java
public void setName(String newName)
{
name = newName;
}
public String getName()
{
return name;
}
public void writeOutput() {
System.out.println("Name: " + name);
}
}
Creating and Clearing objects
Once an object has been created, it requires some
memory space.
To create an object of a particular class use the new
operator in Java. For Example:
Box new_box =new Box(3,4,5)
In C++ we can use the syntax:
ClassName ObjectName;
For Example
Employee workers[4];//4 employees
Creating and Clearing objects
Once the object is no longer useful, it has to be
cleared from memory.
In Java, you do not need to explicitly destroy or
remove an object when it is no longer needed.
Java automatically flags unused objects and
applies garbage collection when appropriate
In C++, to clear unwanted objects from memory we
define special type of method known as a
destructor
What is a destructor in C++?
It is a member function which deletes an object.
A destructor function is called automatically when the
object goes out of scope:
(1) the function ends
(2) the program ends
(3) a block containing temporary variables ends
(4) a delete operator is called
A destructor has:
(i) the same name as the class but is preceded by a tilde (~)
(ii) no arguments and return no values
Constructors and destructors in C++
class base {
int a, b;
public:
base (int, int); //constructor interface
void display( ); //display method interface
~base ( ); //destructor
};
The class base has three methods one of which is a
constructor, a display and a destructor.
C++ Example 1
include<iostream>
using namespace std;
class Demo{
public:
Demo();
~Demo();
};
Demo::Dem()
{
cout<<"Welcome. This is OOP"<<endl;
}
Example 1
Demo::~Demo()
{
cout<<"Good bye\n";
}
int main(){
Demo Greetings;
cout<<"Demostrates a constructor and
displays goodbye when";
cout<<" a destructor is called\n";
return 0;
}
C++ Example 2
#include<iostream>
using namespace std;
class Employee {
private:
int idNum;
double salary;
public:
Employee()
{
int idNum = 120;
double salary=100.0;
Example 2
cout<<"Id number "<<idNum<<"\tSalary is
"<<salary<<endl;
cout<<endl;
}
~Employee ()//object is cleared from memory
{
cout<<"Object cleared from RAM\n";
}
};
void main(){
Employee workers;//constructor called
}
Interface and Implementation
In most OOP languages, the distinction between
interface and implementation is manifest on two
distinct levels:
Within a class, separation between interface and
implementation part
Interface descriptions and implementation bodies
appearing in separate files (or separate area of
same file).
For example, in C++, *.h files for interface and
implementation and *.cpp is the driver file.
Sale Class Interface file in C++
40
/* interface description for Sale class
saved with .h extension */
#ifndef SALE_H
#define SALE_H
//sale class interface definition
class Sale {
private:
float taxRate;
float total;
Sale Class Interface file in C++
41
//public methods prototypes
public:
Sale (float rate);
void calSales (float cost);
float getTotal ();
};
#endif
Implementation of Sale class
/* implementation of Sale class saved with .h
extension */
#include "sales_constructor_interface_only.h“
Sale::Sale (float rate) {
taxRate = rate;
}
void Sale::calSales (float cost){
total = cost + (cost*taxRate);
}
float Sale::getTotal () {
return total; }
Main program body
/* main allows the user to process sales
saved with .cpp extension */
#include<iostream>
#include<iomanip>
using namespace std;
#include "sales_implementation.h“
int main()
{
Sale cashier(0.16);//object cashier
float amount;
Main program body
cout<<fixed<<showpoint<<setprecision(2);
cout<<"Enter the amount of sale "<<endl;
cin>>amount;
cashier.calSales(amount);
cout<<"The total sale is
"<<cashier.getTotal()<<endl;
return 0;
}
Interface and implementation in Java
In Java interfaces are also used to separate design
from coding as class method headers are specified
but not their bodies.
This allows compilation and parameter consistency
testing prior to the coding phase.
We use the key words interface and implements.
When you create a class that uses an interface, you
reference the interface with the phrase implements
Interface_list
Interface and implementation in Java
public interface Job
{
public void work();//no implementation
}
public class WorkingClass implements Job
{
public void work(String job_title){
//some implementation code
}
}
What Next?
Inheritance and Polymorphism
