Object-Oriented Programming

Lecture 2: Classes and Objects

Dr. L H!ng Ph"#ng -- Department of Mathematics, Mechanics and Informatics, VNUH

July 2012
1

Friday, July 27, 12

 Content

Class

Object

More on class

Enum types

Package and the class path

Documentation comments for class

Number and String

2

Friday, July 27, 12

 Class
Recall that a class is a blueprint from which individual objects are created.

Classes are defined in the following way:

class MyClass {
// field, constructor, and
// method declarations
}
The class body contains all the code that provides for the life cycle of the
objects created from the class:

Constructors for initializing new objects

Declarations for the fields that provide the state of the class

Methods to implement the behavior of the class and its objects

3

Friday, July 27, 12

 Class

More complicated declaration of class:

class MyClass extends MySuperClass implements YourInterface {
// field, constructor, and
// method declarations
}
This means that MyClass is a subclass of MySuperClass and that it
implements the YourInterface interface.

You can add access modifiers like public, protected, private at the
beginning, which determine what other classes can access MyClass
(discuss later).

Friday, July 27, 12

 Declaring member variables

There are several kinds of variables:

Member variables in a class--these are called fields.

Variables in a method or a block of code--these are called local

variables.

Variables in method declaration--these are called parameters.

The Bicycle class uses the following lines of code to define its fields:
int cadence;
int speed;
int gear;

Friday, July 27, 12

 Declaring member variables
class Bicycle {

In the sprit of encapsulation, it private int cadence;

private int speed;
is common to make fields private int gear;

private. public Bicycle(int startCadence, int startSpeed,

int startGear) {
gear = startGear;
This means that they can only cadence = startCadence;
speed = startSpeed;
be directly accessed from the }

Bicycle class. void changeCadence(int newValue) {

cadence = newValue;
}
We are still able to access the void changeGear(int newValue) {
gear = newValue;
field values from outside of }
void speedUp(int increment) {
the class through public speed = speed + increment;
methods defined by the class. }
void applyBrakes(int decrement) {
speed = speed - decrement;
}
} 6

Friday, July 27, 12

 Naming rules and conventions

All variables follow the same naming rules and conventions defined
by the Java language.

The same naming rules and conventions are used for methods and
class names, except that

The first letter of a class name should be capitalized.

the first (or only) word in a method name should be a verb.

Friday, July 27, 12

 Defining methods

An example of a typical method declaration:

public double calculateAnswer(double wingSpan, int numberOfEngines,
double length, double grossTons) {
//do the calculation here
}
The only required elements of a method declaration are the methods
return type, name, a pair of parentheses, (), and a body between
braces, { }.

Two of the elements of a method declaration comprise the method

signature--the methods name and parameter types.
calculateAnswer(double, int, double, double)

Friday, July 27, 12

 Defining methods

More generally, method declarations have 6 components, in order:

1. A modifier, such as public, protected, private;

2. The return type or void if the method does not return a value;

3. The method name which follow naming rules and conventions;

4. The parameter list in parentheses; this list can be empty;

5. An exception list (to be discussed later);

6. The method body, enclosed between braces.

9

Friday, July 27, 12

 Overloading methods

The Java programming language public class DataArtist {

//...
supports overloading methods, and
Java can distinguish between public void draw(String s) {
//...
methods with different method }
signatures. public void draw(int i) {
//...
}
This means that methods within a public void draw(double f) {
//...
class can have the same name if they }
have different parameter lists. public void draw(int i, double f) {
//...
}
}

10

Friday, July 27, 12

 Providing constructors

A class contains constructors that are invoked to create objects from

the class blueprint.

Constructor declaration looks like method declaration, except that

they use the same name of the class and have no return type.

The class Bicycle has one constructor:

public Bicycle(int startCadence, int startSpeed, int startGear) {
gear = startGear;
cadence = startCadence;
speed = startSpeed;
}

11

Friday, July 27, 12

 Providing constructors
To create a new Bicycle object called myBike, a constructor is called by the
new operator:
Bicycle myBike = new Bicycle(30, 0, 8);

Bicycle(30, 0, 8) creates space in memory for the object and initializes
its fields.

Bicycle class can define another constructor, for example:

public Bicycle() {
gear = 1;
cadence = 10;
speed = 0;
}

Bicycle yourBike = new Bicycle(); invokes the no-argument constructor
to create a new Bicycle object called yourBike.
12

Friday, July 27, 12

 Providing constructors

The compiler automatically provides a no-argument, default

constructor for any class without constructors.

This default constructor will call the no-argument constructor of the

superclass.

If the superclass does not have a no-argument constructor, the

compiler will complain, so you must verify that it does.

If your class has no explicit superclass, then it has an implicit

superclass of Object, which does have a no-argument constructor.

13

Friday, July 27, 12

 Providing constructors

You can use access modifiers in a constructors declaration to control

which other classes can call the constructor.

Question: How to create a singleton object from a class?

14

Friday, July 27, 12

 Use a superclass constructor
public class MountainBike extends Bicycle {

// the MountainBike subclass has one field

public int seatHeight;

// the MountainBike subclass has one constructor

public MountainBike(int startHeight, int startCadence,
int startSpeed, int startGear) {
super(startCadence, startSpeed, startGear);
seatHeight = startHeight;
}

// the MountainBike subclass has one method

public void setHeight(int newValue) {
seatHeight = newValue;
}
}

15

Friday, July 27, 12

 Passing information to a method
or a constructor
The following is a method that computes the monthly payments for a home
loan, based on the amount of the loan, the interest rate, the number of periods,
and the future value of the loan.
public double computePayment(double loanAmt, double rate,
double futureValue, int numPeriods) {
double interest = rate / 100.0;
double partial1 = Math.pow((1 + interest), -numPeriods);
double denominator = (1 - partial1) / interest;
double answer = (-loanAmt / denominator)
- ((futureValue * partial1) / denominator);
return answer;
}
The name of a parameter must be unique in its scope. It cannot be the name of
a local variable within the method.

A parameter can have the same name as one of the classs fields, which is
conventionally used only within constructors.
16

Friday, July 27, 12

 Passing primitive data type
arguments
Primitive arguments such as an public class PassPrimitiveByValue {
int or a double are passed into public static void main(String[] args) {
methods by value. int x = 3;
passMethod(x);
System.out.println("x = " + x);
This means that any changes to }
the values of the parameters
public static void passMethod(int p) {
exist only within the scope of the p = 10;
method. }
}

When the method returns, the

parameters are gone and any
changes to them are lost.

17

Friday, July 27, 12

 Passing reference data type
arguments
Reference data type parameters, such as objects, are also passed by
value.

This means that when the method returns, the passed-in reference still
references the same object as before.

However, the value of the objects fields can be changed in the

method, if they have the proper access level.

18

Friday, July 27, 12

 Passing reference data type
arguments
public class Circle { public void moveCircle(Circle circle, int deltaX,
private int x, y, radius; int deltaY) {
// code to move origin of
public void setX(int x) { // circle to x+deltaX, y+deltaY
this.x = x; circle.setX(circle.getX() + deltaX);
} circle.setY(circle.getY() + deltaY);
public int getX() {
return x; // code to assign a new
} // reference to circle
public int getY() { circle = new Circle(0, 0);
return y; }
}
public void setY(int y) { Circle myCircle = new Circle(5, 5);
this.y = y; moveCircle(myCircle, 20, 50);
}
}

What are the coordinates of myCircle

after invoking this?
19

Friday, July 27, 12

 Passing reference data type
arguments
Inside the method, circle initially refers to myCircle. The method
changes the x and y coordinates of the object that circle references (that
is, myCircle).

These changes will persist when the method returns.

Then circle is assigned a reference to a new Circle object with x = y = 0.

However, this assignment has no permanence because the reference

was passed in by value and cannot change.

When the method returns, myCircle still references the same Circle
object as before the method was called.
20

Friday, July 27, 12

 Content

Class

Object

More on class

Enum types

Package and the class path

Documentation comments for class

Number and String

21

Friday, July 27, 12

 Creating objects
A class provides the blueprint for objects; you create an object from a class.
Point originOne = new Point(23, 94);
Rectangle rectOne = new Rectangle(originOne, 100, 200);
Rectangle rectTwo = new Rectangle(50, 100);

Each of these statements creates an object and assigns it to a variable.

Each statement has 3 parts:

Declaration: associate a variable name with an object type;

Instantiation: the new keyword is an operator that creates the object;

Initialization: a call to a constructor which initializes the new object.

22

Friday, July 27, 12

 Declaring a variable to refer to an
object
To declare a variable: type name;

With a primitive variable, this declaration reserves the proper amount

of memory for the variable.

If we declare a reference variable like this: Point originOne;

Its value will be undetermined until an object is actually created and

assigned to it.

You must create and assign an object to originOne before you use it in
your code; otherwise you will get a compilation error.

The variable originOne currently references to nothing:

23

Friday, July 27, 12

 Instantiating a class

The new operator instantiates a class by allocating memory for a new

object and returning a reference to that memory. The new operator also
invokes the object constructor.

Point originOne = new Point(23, 94);

Heres the code for the Point class which has a single constructor:
public class Point {
public int x = 0;
public int y = 0;

public Point(int a, int b) {

Normally, fields x = a;
are not public. y = b;
}
}
24

Friday, July 27, 12

 Instantiating a class public class Rectangle {
public int width = 0;
public int height = 0;
public Point origin;

public Rectangle() {
origin = new Point(0, 0);
The class Rectangle has 4 constructors. }
public Rectangle(Point p) {
origin = p;
Each constructor lets you provide }
public Rectangle(int w, int h) {
initial values for the rectangles size origin = new Point(0, 0);
width = w;
and origin, using both primitive and height = h;
reference types. }
public Rectangle(Point p, int w, int h) {
origin = p;
width = w;
If a class has multiple constructors, height = h;
}
they must have different signatures. public void move(int x, int y) {
origin.x = x;
origin.y = y;
The Java compiler differentiates the }
public int getArea() {
constructors based on the number and return width * height;
}
the type of the arguments. }
25

Friday, July 27, 12

 Instantiating a class
Rectangle rectOne = new Rectangle(originOne, 100, 200);

public class Rectangle {

public int width = 0;
public int height = 0;
public Point origin;

//...
public Rectangle(Point p, int w, int h) {
origin = p;
width = w;
height = h;
}
}

26

Friday, July 27, 12

 Using objects

Once an object is created, we can use it to do something:

use the value of one of its fields;

change one of its fields;

call one of its methods to perform an action.

Use a simple name for a field within its class, like this:
System.out.println("Width and height are: " + width + ", " + height);

27

Friday, July 27, 12

 Using objects
Code that is outside the objects class must use an object reference followed by the
dot operator: objectReference.fieldName

In the code outside Rectangle class and if we have an Rectangle object named
rectOne:
System.out.println("Width of rectOne: " + rectOne.width);
System.out.println("Height of rectOne: " + rectOne.height);

Recall that the new operator returns a reference to an object. So we could use the
value returned from new to access a new objects field:

int height = new Rectangle().height;

After executing this statement, the program has no longer reference to this created
Rectangle, because the program never stored the reference anywhere (GC).
28

Friday, July 27, 12

 Calling an objects method

To call an objects method: objectReference.methodName(argumentList);

The Rectangle class has two methods: move(int, int) to change the
rectangles origin, and getArea() to compute the rectangles area.
System.out.println("Area of rectOne: " + rectOne.getArea());
// ...
rectTwo.move(40, 72);

If some methods returns a value (such as getArea()), we can use the

method invocation in expressions:
int areaOfRectangle = new Rectangle(100, 50).getArea();

29

Friday, July 27, 12

 The garbage collector (GB)
Some object-oriented languages require that

you keep track of all the objects you create, and

you explicitly destroy them when they are no longer needed.

Managing memory explicitly is tedious and error-prone.

The Java platform allows you to create as many objects as you want
and you dont have to worry about destroying them.

The Java runtime environment deletes objects when it determines that

they are no longer being used. This process is called garbage collection.
30

Friday, July 27, 12

 The garbage collector (GB)

An object is eligible for garbage collection when there are no more

references to that object:

variables go out of scope;

variables are explicitly set to null.

The garbage collector periodically frees the memory used by the

objects that are no longer referenced.

The garbage collector does its job automatically when it determines

that the time is right.

31

Friday, July 27, 12