Session 03

Classes and Objects

(http://docs.oracle.com/javase/tutorial/java/javaOO/index.
html)

Session 03 - Classes and Objects

 Objectives
1-Programming Paradigms
2-OOP basic concepts
3-How to identify classes
4-Hints for class design
5-How to declare/use a class
6-Common modifiers (a way to hide some members in a
class)
7-Memory Management in Java
8-Garbage Collection
9-Case study: Java program for managing a list of persons

Session 03 - Classes and Objects

 1- Programming Paradigms
• High-level programming languages (from 3rd
generation languages) are divided into (Wikipedia):
Paradigm Description
Procedural-oriented (imperative) Program= data + algorithms. Each algorithm is
paradigm-POP implemented as a function (group of statements)
(3rd generation language) and data are it’s parameters (C-language)

Object-oriented paradigm (OOP) Programs = actions of some objects. Object = data

(3rd generation language) + behaviors. Each behavior is implemented as a
method ( C++, Java, C#,…)
Functional paradigm Domain-specific languages. Basic functions were
(4th generation language) implemented. Programs = a set of functions ( SQL)

Declarative/Logic paradigm Program = declarations + inference rules ( Prolog,

(5th generation language) CLISP, …)

Session 03 - Classes and Objects

 Programming Paradigms: POP vs. OOP
Procedure-Oriented Program Class A
{
data1
data1
data2
Function1 ()
Function1 (data1)
Function2 ()
Function2 (data1)
}
Function3 (data2)
Function4 (data2) Class B
{
data2 Common
Object = Data + Methods
Function3 () methods
Basic Concepts Function4()
for
- Encapsulation Particular accessing a
methods: } data field:
- Inheritance Constructors
- Polymorphism Type getField()
void setField (Type newValue)
Session 03 - Classes and Objects
2-OOP Concepts

• Encapsulation
• Inheritance
• Polymorphism

Session 03 - Classes and Objects

 OOP Concepts: Encapsulation

Aggregation of data and behavior.

• Class = Data (fields/properties) + Methods
• Data of a class should be hidden from the outside.
• All behaviors should be accessed only via methods.
• A method should have a boundary condition: Parameters
must be checked (use if statement) in order to assure that
data of an object are always valid.
• Constructor: A special method it’s code will execute
when an object of this class is initialized.

Session 03 - Classes and Objects

 OOP Concepts: Inheritance
Ability allows a class having members of an
existed class  Re-used code, save time
class PERSON class STUDENT

ID_Num ID_Num
Name Name
YearOfBirth inherited YearOfBirth
Address Address
getID_Num() getID_Num()
setID_Num(newID) setID_Num(newID)
...... ......
“is a”
relationship
RollNum
class STUDENT
Score
extensions
RollNum getScore()
Score setSore(newScore)
getScore() ......
setSore(newScore)
......
Son = Father + extensions

Session 03 - Classes and Objects

 OOP Concepts: Inheritance

How to detect father class?

Finding the intersection of concerned classes.
 Electric Products< code, name, make, price, guaranty, voltage, power>
 Ceramic Products < code, name, make, price, type >
 Food Products < code, name, make, price , date, expiredDate >

Product
code
name
make
price

ElectricProduct Food
guaranty Ceramic
date
voltage type expiredDate
power
Session 03 - Classes and Objects
 OOP Concepts: Polymorphism

Ability allows many versions of a method

based on overloading and overriding
methods techniques.
Overloading: A class can have some
methods which have the same name but
their parameter types are different.
Overriding: A method in father class can be
overridden in it’s derived classes (body of a
method can be replaced in derived classes).
Session 03 - Classes and Objects
 3- How to Identity a Class
• Main noun: Class
• Nouns as modifiers of main noun: Fields
• Verbs related to main noun: Methods
class Student {
String code;
String name;
int bYear;
Employee details of a student String address;
include code, name, year of void input() {
birth, address. <code>
Write a Java program that will }
allow input a student, output void output() {
his/her. <code>
}
}
10
 4-Hints for class design
Head
• Identifying classes: Coupling Eye1 High coupling
( Bad design)
• Is an object’s reliance on Eye2
knowledge of the internals of
another entity’s implementation.
• When object A is tightly coupled
to object B, a programmer who
wants to use or modify A is Head Eye
required to have an leftEye
inappropriately extensive rightEye
Eye
expertise in how to use B.
Low coupling
( Good design)

11
 Hints for class design
• Implementing methods: Cohesion is the degree to
which a class or method resists being broken down
into smaller pieces.
class A
M1()
{
class A Operation 1
M() }
{ M2()
Operation 1
{
Operation 2 Operation 2
} }
M()
Low cohesion(bad design) { M1(); M2();
}

High cohesion(good design)

12
 5- Declaring/Using a Java Class

[public] class ClassName [extends FatherClass] {

[modifier] Type field1 [= value];
[modifier] Type field2 [= value]; Modifiers will be
// constructor introduced later.
[modifier] ClassName (Type var1,…) {
<code>
How many
}
constructors should
[modifier] methodName (Type var1,…) { be implemented? 
<code> Number of needed
} ways to initialize an
……. object.
}
What should we will write in constructor’s body?  They usually
are codes for initializing values to descriptive variables
Session 03 - Classes and Objects
 Defining Constructors

• Constructors that are invoked to create

objects from the class blueprint.
• Constructor declarations look like method
declarations—except that they use the
name of the class and have no return type.
• The compiler automatically provides a no-
argument, default constructor for any class
without constructors.

Session 03 - Classes and Objects

 Defining Methods

• Typical method declaration:

[modifier] ReturnType methodName (params) {
<code>
}

• Signature: data help identifying something

• Method Signature:
name + order of parameter types

Session 03 - Classes and Objects

Passing Arguments a Constructor/Method

• Java uses the mechanism passing by

value. Arguments can be:
• Primitive Data Type Arguments
• Reference Data Type Arguments (objects)

Session 03 - Classes and Objects

 Creating Objects

• Class provides the blueprint for objects;

you create an object from a class.
• Point p = new Point(23, 94);
• Statement has three parts:
• Declaration: are all variable declarations that
associate a variable name with an object type.
• Instantiation: The new keyword is a Java operator
that creates the object (memory is allocated).
• Initialization: The new operator is followed by a call
to a constructor, which initializes the new object
(values are assigned to fields).
Session 03 - Classes and Objects
 Type of Constructors
Create/Use an object of a class
• Default constructor: Constructor with no parameter.
• Parametric constructor: Constructor with at least one
parameter.

• Create an object
ClassName obj1=new ClassName();
ClassName obj2=new ClassName(params);
• Accessing a field of the object
object.field
• Calling a method of an object
object.method(params)
Session 03 - Classes and Objects
 Demo: If we do not implement any
constructor, compiler will insert to the class a
system default constructor

In this demonstration (package

point1):
- The class IntPoint1 represents a
point in an integral two
dimensional coordinate.
- The class IntPoint1_Use having
the main method in which the
class IntPoint1 is used.

Session 03 - Classes and Objects

 Demo: If we do not implement any
constructor, compiler will insert to the class a
default constructor
System constructor will clear all
bits in allocated memory Order for
initializing an
object

(2) Setup
values

y 0
100 x 0

(1) Memory
allocation

p 100
An object variable is a reference

Session 03 - Classes and Objects

 Demo: If we implement a constructor,
compiler does not insert default constructor

This demonstration will depict:

- The way to insert some
methods automatically in
NetBeans
- If user-defined constructors
are implemented, compiler
does not insert the system
default constructor

Session 03 - Classes and Objects

 Demo: If we implement a constructor,
compiler does not insert default constructor
Insert constructor

Parameter names are the same as those

in declared data filed. So, the keyword
this will help distinguish field name and
parameter name.
this.x means that x of this object

Session 03 - Classes and Objects

 Demo: If we implement a constructor,
compiler does not insert default constructor
Accessing each data field is usually supported by :
A getter for reading value of this field
Insert getter/setter A setter for modifying this field

Session 03 - Classes and Objects

 Demo: If we implement a constructor,
compiler does not insert system constructor

Session 03 - Classes and Objects

Explain the result of the following program

Session 03 - Classes and Objects

 6- Common Modifiers
• Modifier (linguistics)is a word which can bring out the
meaning of other word (adjective noun, adverb 
verb)
• Modifiers (OOP) are keywords that give the compiler
information about the nature of code (methods), data,
classes.
• Java supports some modifiers in which some of them are
common and they are called as access modifiers
(public, protected, default, private).
• Common modifiers will impose level of accessing on
• class (where it can be used?)
• methods (whether they can be called or not)
• fields (whether they may be read/written or not)
Session 03 - Classes and Objects
Outside of a Class

Inside of the class

Inside of the InPoint2_Use and it is
class InPoint2 outside of the class
IntPoint2

Outside of the class A is another class

where the class A is accessed (used)

Session 03 - Classes and Objects

 Common Modifiers

Access level
Applied to
Free-accessing public

interface
package/ subclass

protected
class
outside cannot access
private
members of
interface/class
package
no specifier
(default)
Interface is a group of prototyped
methods and they will be
Order: implemented in a class afterward.
public > protected > default > private It will be introduced later.
Session 03 - Classes and Objects
Common Modifiers

Session 03 - Classes and Objects

Demo: Overloading Method

Session 03 - Classes and Objects

 Demo: Methods with
Arbitrary Number of Arguments
A group is treated as an array
group.length number of elements
group[i]: The element at the position i

Session 03 - Classes and Objects

 7- Memory Management in Java
▪ Review: In C, 4 basic regions: Data segment (for global
data), code segment (for statements), stack (for local
data of functions when they are called), heap (for
dynamic data). C/C++ programmers must explicitly
manage the heap of a program.
▪ How Java heap is managed? (Refer to:
http://docs.oracle.com/javase/specs/)
• JVM support the garbage collector in order to free Java
programmers from explicitly managing heap
• Java heap is managed by 2 lists: Free block list, Allocated block
list
• Initial, free block list is all the heap
• After very much times for allocating and de-allocating memory,
fragmented and free blocks are not contiguous
Session 03 - Classes and Objects
 Memory Management in Java

❖ How are data allocated in heap?

- Way: First fit
- If there is no blank block is fit, Java memory manager must compact
memory in order to create more larger free block
❖ Heap structure in Java
• Static heap contains class declarations  Invariable, garbage
collection is not needed
• Dynamic heap is divided into two sections: The first contains
objects and the second contains relations between object and
appropriate method in static heap. When an object is not used
(garbage), it’s memory can be de-allocated.
• When an object is created, a field for reference to the class
declaration is automatically added
• The next slide will depict it..

Session 03 - Classes and Objects

 Memory Management in Java
Class1 Definition
-Constants/fields 1000
Dynamic
-Method table Fields heap
obj1:10000
(m1,,add1) 1000 Section 1
(2)
(m2,,add2) (Garbage
obj2:8000
Fields
(4)
collection is
m1 applied)
m2 (3) (1)
1000
Class2 definition
-Constants/fields Dynamic heap Section 2 Dynamic
(5) Code of m1()
-Method table executes ( Entry: 2 references) heap
(10000, m1)  obj1.m1() Section 2
(m3,,add3)
Relations
(m4,,add4) (8000, m4)  obj2.m4() object-
m3 method
m4 500

Static heap Session 03 - Classes and Objects

 8- Garbage Collection
• Most modern languages permit you to allocate
data storage during a program run. In Java, this
is done directly when you create an object with
the new operation and indirectly when you call a
method that has local variables or arguments.
• Local data of a method include: return data,
parameters, variables are declared in the body
of the method.
• Method locals are allocated space on the stack
and are discarded when the method exits, but
objects are allocated space on the heap and
have a longer lifetime.
Session 03 - Classes and Objects
 Garbage Collection…

• In Java, you never explicitly free memory that

you have allocated; instead, Java provides
automatic garbage collection.
• The runtime system keeps track of the memory
that is allocated and is able to determine
whether that memory is still useable.
• Garbage collector has the lowest priority. It runs
only when the system heap becomes
exhausted.
• A data is treated as garbage when it is out of
it’s scope or an object is assigned to null.
Session 03 - Classes and Objects
 Garbage Collection …

Object obj1 = new Object();

int x= 5;
if (x<10) {
Object obj2= new Object();
Scope of a variable begins at
int y=3;
the line where it is declared and
ends at the closing bracket of
………
the block containing it
}
int t=7;
obj1 = null; obj2, y are out of scope ( they
t*=8; are no longer used)
……
obj1= null  Memory allocated
to obj1 is no longer used

Session 03 - Classes and Objects

 Garbage Collection…

When does garbage collector execute?

• Garbage collector has the lowest priority.
So, it runs only when program’s memory is
exhausted.
• It is called by JVM only. We can not
activate it.

Session 03 - Classes and Objects

9- Case study and Sample Report
• Reports must be written in your notbook
• A report includes 5 parts:
1- Problem Description
2- Analysis
3- Design
4- Implementation
5- Testing
• Hereafter, a sample report is introduced.

39
 Case Study 1 Report
1- Problem Description
• Each person details include code, name,
and age.
• Write a Java program that allows users
adding a new person to the list, removing
a person having a known code from the
list, updating details of a known-code
person, listing all managed persons in
descending order of ages using a simple
menu.
40
 Report…

2- Analysis
From the problem description, following use-cases are
identified:

-System/program is
expressed as a bounded
rectangle.
- Each function is
expressed by a verb in an
ellipse
-User runs a function is
expressed as a line

41
 Report…
3- Design
3.1- Class Design
From the problem description, concepts in the problem domain
are expressed by following classes:
Class Person
Description for a person
Data: String code; String name; int age
Methods:
Constructors
Getters, setters
void input() for collecting data
String toString() to get data in string format

42
 Report…
Class PersonList
Description for a list of persons
Data:
Person[] list; // current list
int count // current number of persons
Methods:
Constructors
Getters, setters
void add(); // add a new person. Data are collected from keyboard
int find (String aCode); // Find the index of the person whose code is known
void remove()// remove a person. His/ her code is accepted from keyboard
void sort(); // descending sort the list based on their ages
void update(); // update a person, data are accepted from keyboard
void print(); // print the list

43
 Report…
Class Menu
Description for a menu
Data
String[] hints; // list of hints
int n; // current number of hints
Methods:
Menu(int n): constructor for initializing a menu containing n options
void add (String aHint); // add an option
int getChoice(); // get an option

Class ManagingProgram1
Description for the program
Data: none
Methods:
main(…): main method of the program

44
 Report…
3.2- Program structure

Algorithms
Please see comments in codes.

45
 Report…
3.3- User interface

Menu of the program will be seen as:

1-Add new person

2-Remove a person
3-Update a person
4-List
5-Quit

46
 Report…
4- Implementation
Initial data of the program ( if any, file ………)
Please explore the software structure
Software
Please run the program
5- Testing
No. Case State
1 Add new person Passed
Code: not duplicate Passed
Name: …. not passed
Age: …. ……
2 Remove a person Passed
3 Update aperson Passed
4 List ……..
… ………………. …..
47
 Recommendations

Code Conventions:
• Indentation: 4 blanks at the beginning of
each code line
• Comments in the code must be carried out.
• Names:
• One-word name: lowercase
• Multi-word name: The first word: lowercase,
remaining words: The first character is
uppercase, others are lowercase.

Session 03 - Classes and Objects

 Recommendations
A sample :
/*
Author: ……
Date: …….
This class represents ……..
*/
class ClassName ……. {
int data; // Which does data represent?
….
/* What is the goal of the method
Which does the return data represent?
*/
Method implementation ….. {
…
}
}

Session 03 - Classes and Objects

Case study: Design Guide

50
 Case study:
Code Supported

this:
reference of
the current
object

51
Case study: Implementation

52
Case study: Implementation

53
Case study: Implementation

54
Case study: Implementation

55
Case study: Implementation

56
Case study: Implementation

57
 Summary
• The anatomy of a class, and how to declare
fields, methods, and constructors.
• Hints for class design:
• Main noun  Class
• Descriptive nouns  Fields
• Methods: Constructors, Getters, Setters, Normal methods
• Creating and using objects.
• To instantiate an object: Using appropiate
constructior
• Use the dot operator to access the object's
instance variables and methods.
Session 03 - Classes and Objects