Object Oriented
Programming Techniques
1
Lecture 5: Classes
Paradigm shift
Procedural (or Imperative) Programming
Converting program specifications to method-
based code
Style of programming found in C, Pascal, Basic, …
Data and operations on data are separate
Object Oriented Programming
All the power of procedural programming… plus
some!
Supported by C++, C#, Java, Perl, Python, …
Data and operations on data are bundled together
in a structure called an Object
OOP: Lecture #8 Compiled By Umm-e-Laila 2
Classes
When working with objects, the first
thing to do is to create a blueprint of
the object…
An object is a specific instance of this
blueprint
The blueprint just describes how we
create objects
In Java, we call these blueprints
Classes
OOP: Lecture #8 Compiled By Umm-e-Laila 3
4 Classes
A class is a collection of fields (data) and methods (procedure or
function) that operate on that data.
Circle
centre
radius
circumference()
area()
5 Classes
A class is a collection of fields (data) and
methods (procedure or function) that operate
on that data.
The basic syntax for a class definition:
class ClassName [extends SuperClassName]
{
[fields declaration]
[methods declaration]
}
Bare bone class – no fields, no methods
public class Circle {
// my circle class
}
6 Adding Fields: Class
Circle with fields
Add fields
public class Circle {
public double x, y; // centre coordinate
public double r; // radius of the circle
The fields (data) are also called the instance varaibles.
7 Adding Methods
A class with only data fields has no life.
Objects created by such a class cannot
respond to any messages.
Methods are declared inside the body of
the class but immediately after the
declaration of data fields.
The general form of a method
declaration is:
type MethodName (parameter-list)
{
Method-body;
}
8 Adding Methods to Class
Circle
public class Circle {
public double x, y; // centre of the circle
public double r; // radius of circle
//Methods to return circumference and area
public double circumference() {
return 2*3.14*r;
}
public double area() {
return 3.14 * r * r;
}}
Method Body
9 Data Abstraction
Declare the Circle class, have created a new
data type – Data Abstraction
Can define variables (objects) of that type:
Circle aCircle;
Circle bCircle;
Alternative thinking
Programming in object oriented
languages is really just an alternative
way of thinking about problems
It’s a way of organising your code so
that the data and the operations on
that data are bundled together
Object types are just extended types…
There’s a hierarchy in OO code that
ultimately boils down to storing data in the
8 primitive data types but with methods to
go with them to mean that your extended
types are much more powerful
OOP: Lecture #8 Compiled By Umm-e-Laila 10
Object-oriented programming
So we’ve made our blueprint for Circle objects (though its not yet
complete…)
An object-oriented program can be viewed as a collection of
cooperating objects
Lets think about the data and operations of some other possible
objects
Circle — Data: radius; Operations: area, circumference…
Person class
Attributes: name, address, phone number
Methods: change address, change phone number
Alice object
Name is Alice, address is …
Bob object
Name is Bob, address is …
OOP: Lecture #8 Compiled By Umm-e-Laila 11
A Class as an Outline
12
Defining objects
Our Circle class isn’t quite ready yet…
You can only run a class if it has a main
method and even then you’re not
creating Objects!
The class we have tells Java what the
object looks like but it doesn’t tell Java
how to make a circle Object
The class variable, radius, doesn’t have
a default value so we need to find a
way to give it one
OOP: Lecture #8 Compiled By Umm-e-Laila 13
Constructor methods
A constructor method is a special
method that…
… has no return type (not even void!)
… has the same name as the class
public class Circle {
Object
// Its purpose
data is to set-up the object
according
double radius; to some rules
ForCircle(double
public our Circle class…
radius) {
this.radius = radius;
}
…
}
OOP: Lecture #8 Compiled By Umm-e-Laila 14
Constructor methods
public class Circle {
// Object data
double radius;
public Circle(double radius) {
this.radius = radius;
} We can have method variables with the same
…
}
name as class variables… However, if we
want to refer to the class variable, we must
prefix it with this.
This method will set the class variable to the value
of the parameter
A quick note on scope… it may seem like we’ve
used radius twice…
OOP: Lecture #8 Compiled By Umm-e-Laila 15
Creating objects
Now our Circle is complete we can start
using Circle objects
We’ve looked at arrays of monomorphic
data… Objects are a bit like arrays of
non-monomorphic data
They require a small amount of
contiguous memory to store all their
properties
To give them memory we use the new
keyword
OOP: Lecture #8 Compiled By Umm-e-Laila 16
Creating objects
With arrays, the new keyword just reserves enough
memory and sets default values
With objects, the new keyword reserves enough
memory and also calls the constructor function we
just wrote
The syntax is almost the same as for arrays
[ObjectType] variableName = new [ObjectType]([parameters]);
So to create one of our Circles…
Circle c = new Circle(0.5);
This will call the constructor method in the Circle
class with the radiusCompiled
OOP: Lecture #8
value of 0.5
By Umm-e-Laila 17
Creating objects
Lets create a new class to test our
public class CircleTest {
Circle
public staticout
void main(String[] args) {
CircleTest.java
Circle c = new Circle(0.5);
Circle c2 = new Circle(1.0);
System.out.println(“The area of c is: “ +
c.area());
System.out.println(“The circumference of c2 is:
” +
c2.circumference());
}
}
OOP: Lecture #8 Compiled By Umm-e-Laila 18
Creating objects
You don’t have to write a constructor
If you choose not to, Java will create a
default constructor
The default constructor does not set
any values so the object will do nothing
until you start interacting with it
Also, much like overloaded methods we
can write multiple different constructors
with different parameter lists
OOP: Lecture #8 Compiled By Umm-e-Laila 19
Differences between variables of
primitive
20 Data types and object types
Primitive type int i = 1 i 1
Object type Circle c c reference
c: Circle
Created using
new Circle() radius = 1
Copying Variables of Primitive
Data
21 Types and Object Types
Primitive type assignment Object type assignment
i=j c1 = c2
Before: After: Before: After:
i 1 i 2 c1 c1
j 2 j 2 c2 c2
c1: Circle c2: Circle
radius = 5 radius = 9
Passing Objects to Methods, cont.
22
main printAreas
method method
times
n 5 5 Pass by value (here the value is 5)
myCircle Reference Reference Pass by value (here the value is the
reference for the object)
myCircle: Circle
radius = 1
Array
23
of Objects
Circle[] circleArray = new Circle[10];
An array of objects is actually an array of
reference variables. So invoking
circleArray[1].findArea() involves two levels
of referencing as shown in the next figure.
circleArray references to the entire array.
circleArray[1] references to a Circle object.
Array
24
of Objects, cont.
Circle[] circleArray = new
Circle[10];
circleArray reference circleArray[0] Circle object 0
circleArray[1]
… Circle object 1
circleArray[9] Circle object 9
25 Automatic garbage
collection
If an object does not have a reference than that Object
cannot be used in future.
That object becomes a candidate for automatic garbage
collection.
Java automatically collects garbage periodically and
releases the memory used to be used in the future.
A note on comparisons…
All objects have an equals() method
The reason for this is that you can only
compare primitive types with ==
To compare two object types, we must
use:
Object o1 = new Object();
Object o2 = new Object();
if (o1.equals(o2)) {
// do something
}
OOP: Lecture #8 Compiled By Umm-e-Laila 26
Person
27
Class
------------ Person.java ------ defining ---------- PersonTest.java ----- using
Person Person --
public class Person
{
private String _name; public class PersonTest
private String _iceCream; {
public static void main(String[]
public void setName(String args)
newName) {
{ Person joe = new Person();
this._name = newName; // joe.setName(“Joseph”);
this. is optional joe.setIceCream(“Rocky
} Road”);
public void setIceCream(String
newIceCream) { … } Person mary = new Person();
mary.setName(“Mary”);
public void print() mary.setIceCream(“Chocolate
Fudge”);
{ System.out.println(this._nam mary.print(); }
The Point class
Lets look at the object that it returns…
Its a Point object! So lets look at the
Point blueprint (class!)
OOP: Lecture #8 Compiled By Umm-e-Laila 28
The Point class
The Point class has two properties…
OOP: Lecture #8 Compiled By Umm-e-Laila 29
The Point object
… And three constructor methods
OOP: Lecture #8 Compiled By Umm-e-Laila 30
The Point class
And it has a tonne of methods…
OOP: Lecture #8 Compiled By Umm-e-Laila 31
The Point class
…
Some of the methods are inherited
(more on this later!)
OOP: Lecture #8 Compiled By Umm-e-Laila 32
Exercise
So lets try to create our own Point class with a
subset of the methods in Java’s Point class…
We’ll start by creating the data
Then we’ll write methods for:
getting the X coordinate
getting the Y coordinate
moving the point
moving the point relative to its current position
writing the coordinates in a String
checking if the Point is equal to another point
OOP: Lecture #8 Compiled By Umm-e-Laila 33
Example
34
The Mortgage Class
Mortgage
-annualInterestRate: double
-numOfYears: int
-loanAmount: double
+Mortgage()
+Mortgage(annualInterestRate: double,
numOfYears: int, loanAmount: double)
+getAnnualInterestRate(): double
+getNumOfYears(): int
+getLoanAmount(): double
+setAnnualInterestRate(annualInteresteRate: double): void
+setNumOfYears(numOfYears: int): void
+setLoanAmount(loanAmount: double): void
+monthlyPayment(): double
+totalPayment(): double
Example
35 The Count Class
Summary
So now you should be able to:
Write an object specification (class)
Instantiate new instances of this class
Perform actions on its data
