Ton Duc Thang University

Faculty of Information Technology

OBJECT-ORIENTED PROGRAMMING
LAB 4: CLASS, OBJECT, ENCAPSULATION IN OOP
I. Objective
After completing this tutorial, you can:

• Understand how to program an OOP program in Java,

• Understand object and class concepts,

• Understand encapsulation in OOP.

II. Java OOP

In this tutorial, we will focus on two basic concepts of Java OOP:

• Object (Section III),

• Class (Section IV).

III. Object
In the real world, we can find many objects/entities around us, e.g. chair, bike, dog, animal. All these
objects have state(s) and behavior(s). If we consider a dog, then its state is name, breed, color, and the
behavior is baking, wagging the tail, running. That’s it, an object has two characteristics.

• State: represents data (value) of an object,

• Behavior: represents the behavior (functionality) of an object.

IV. Class
In the real world, you will often find many individual objects all the same kind. There may be thousands
of other bicycles in existence, all the same make and model. Each bicycle was built from the same set
of blueprints and therefore contains the same components. In object-oriented terms, we say that your
bicycle is an instance of the class of objects known as bicycles. A class is a blueprint/template from
which individual objects are created.

To define a class in Java, the least you need to determine:

• Class’s name: By convention, the first letter of a class’s name is uppercased and subsequent
characters are lowercased. If a name consists of multiple words, the first letter of each word is
uppercased.

• Variables (State)

Object Oriented Programming (503005) – 2020 1/8

 Ton Duc Thang University
Faculty of Information Technology

• Methods (Behaviors)

• Constructors

• Getter & setter (we will discuss later in this tutorial)

1. Example program
Following is an example of a class:

• Name: Student

• Properties: name, gender, age

• Methods: studying, reading, writing

public class Student

{
String name;
String gender;
int age;

void studying()
{
System.out.println("studying...");
}

void reading()
{
System.out.println("reading...");
}
}
A class can contain the following types of variables:

• Local variables: Variables defined inside methods, constructors or blocks are called local
variables.

• Instance variables: Instance variables are variables within a class but outside any method.

• Class variables: Class variables are variables declared within a class, outside any method, with
the static keyword.

A class can also have methods, e.g., studying(), reading(). Generally, method declarations have
six components, in order:

• Modifiers: such as public, private, and protected.

• The return type: the data type of the value returned by the method, or void if the method does
not return a value.

Object Oriented Programming (503005) – 2020 2/8

 Ton Duc Thang University
Faculty of Information Technology

• The parameter list in parenthesis: a comma-delimited list of input parameters, preceded by their
data types, enclosed by parentheses. If there are no parameters, you must use empty parentheses.

• An exception list (to be discussed later).

• The method body, enclosed between braces: the method’s code, including the declaration of
local variables, goes here.
2. Constructor
Every class has a constructor. If we do not explicitly write a constructor for a class, the Java compiler
builds a default constructor for that class. Each time a new object is created, at least one constructor will
be invoked.

A constructor must have the same name as the class. A class can have more than one constructor, but in
most case, you need to define at least three types of constructor:

• Default constructor, with no parameter

• Parameterized constructor

• Copy constructor
The following program demonstrates how-to defined constructors.

public class Student

{
String name;
String gender;
int age;

public Student()
{
this.name = "";
this.gender = "male";
this.age = 0;
}

public Student(String name, String gender, int age)

{
this.name = name;
this.gender = gender;
this.age = age;
}

Object Oriented Programming (503005) – 2020 3/8

 Ton Duc Thang University
Faculty of Information Technology

public Student(Student st)

{
this.name = st.name;
this.gender = st.gender;
this.age = st.age;
}

void studying()
{
System.out.println("studying...");
}

void reading()
{
System.out.println("reading...");
}
}
In the above program, we use the this keyword to access instance variables. The this keyword is
useful in case of parameterized constructor, we can clearly distinguish the instance variables and input
parameters.

3. Java Access Modifiers

Java provides several access modifiers to set access levels for classes, variables, methods, and
constructors. The four access levels:

• Default: Visible to the package, no modifiers are needed.

• Private: Visible to the class only.

• Public: Visible to the world.

• Protected: Visible to the package and all subclasses (discuss later).

4. Encapsulation
Encapsulation is one of the four fundamental OOP concepts. The other three are inheritance,
polymorphism, and abstraction (we will discuss later).
Encapsulation in Java is a mechanism of wrapping the data (variables) and code acting on the data
(methods) together as a single unit. In encapsulation, the variables of a class will be hidden from other
classes and can be accessed only through the methods of their current class. Therefore, it is also known
as data hiding.
To achieve encapsulation in Java:

• Declare the variables of a class as private/protected.

Object Oriented Programming (503005) – 2020 4/8

 Ton Duc Thang University
Faculty of Information Technology

• Provide public getter and setter methods to modify and view the variable’s values.
The following program illustrates how-to achieve encapsulation in Java OOP program.

public class Student

{
private String name;
private String gender;
private int age;

public Student()
{
this.name = "";
this.gender = "male";
this.age = 0;
}

public Student(String name, String gender, int age)

{
this.name = name;
this.gender = gender;
this.age = age;
}

public Student(Student st)

{
this.name = st.name;
this.gender = st.gender;
this.age = st.age;
}

void studying()
{
System.out.println("studying...");
}

void reading()
{
System.out.println("reading...");
}

public String getName()

{
return this.name;
}

public String getGender()

{
return this.gender;
}

Object Oriented Programming (503005) – 2020 5/8

 Ton Duc Thang University
Faculty of Information Technology

public int getAge()

{
return this.age;
}

public void setName(String name)

{
this.name = name;
}

public void setGender(String gender)

{
this.gender = gender;
}

public void setAge(int age)

{
this.age = age;
}
}

5. Test the class

In order to test an implemented class, we need to define the main method, as follows.

public class StudentTest

{
public static main(String[] args)
{
Student student = new Student("Nguyen Van A", "male", 19);

System.out.println("Name:" + student.getName());
System.out.println("Gender:" + student.getGender());
System.out.println("Age:" + student.getAge());

student.studying();
student.reading();
}
}

V. Exercises
1. A class called Point is designed as shown in the following class diagram. It contains:

• Two private instance variables: x (of the type double) and y (of the type double), with default
0.0 and 0.0, respectively.

• Two overloaded constructors: a default constructor with no argument, and a constructor that
takes 2 double arguments for x coordinate and y coordinate.

Object Oriented Programming (503005) – 2020 6/8

 Ton Duc Thang University
Faculty of Information Technology

• Two public methods: getX() and getY(), which return the x coordinate and the y coordinate of
this instance, respectively.

Implement Point class based on the definition.

2. Implement the Rectangle class which is defined as the following figure.

Object Oriented Programming (503005) – 2020 7/8

 Ton Duc Thang University
Faculty of Information Technology

3. Implement the Student class which is defined as the following figure.

4. Implement the Fraction class which is defined as the following figure.

Object Oriented Programming (503005) – 2020 8/8