Chapter 3: Classes and Objects

Keerthika C
EMP ID:18974
SCOPE

1
 OO Programming Concepts

• Object-oriented programming (OOP) involves programming using

objects. An object represents an entity in the real world that can be
distinctly identified. For example, a student, a desk, a circle, a button,
and even a loan can all be viewed as objects.
• The state of an object (also known as its properties or attributes) is
represented by data fields with their current values. A circle object, for
example, has a data field radius, which is the property that
characterizes a circle. A rectangle object has the data fields width and
height, which are the properties that characterize a rectangle
• The behavior of an object (also known as its actions) is defined by
methods. To invoke a method on an object is to ask the object to
perform an action. For example, you may define methods named
getArea() and getPerimeter() for circle objects. A circle object may
invoke getArea() to return its area and getPerimeter() to return its
perimeter. 2
 OO Programming Concepts
• Objects of the same type are defined using a common class. A class is a
template, blueprint, or contract that defines what an object’s data fields
and methods will be. An object is an instance of a class. You can create
many instances of a class. Creating an instance is referred to as
instantiation.

• The terms object and instance are often interchangeable. The

relationship between classes and objects is analogous to that between an
apple-pie recipe and apple pies: You can make as many apple pies as
you want from a single recipe.

3
 Objects
Class Name: Circle A class template

Data Fields:
radius is _______

Methods:
getArea

Circle Object 1 Circle Object 2 Circle Object 3 Three objects of

the Circle class
Data Fields: Data Fields: Data Fields:
radius is 10 radius is 25 radius is 125

An object has both a state and behavior. The state defines the object,
and the behavior defines what the object does.

4
 Classes

Classes are constructs that define objects of the same type. A Java
class uses variables to define data fields and methods to define
behaviors. Additionally, a class provides a special type of methods,
known as constructors, which are invoked to construct objects from
the class.

5
 Classes
class Circle {
/** The radius of this circle */
double radius = 1.0; Data field

/** Construct a circle object */

Circle() {
}
Constructors
/** Construct a circle object */
Circle(double newRadius) {
radius = newRadius;
}

/** Return the area of this circle */

double getArea() { Method
return radius * radius * 3.14159;
}
}
6
 Classes
• The Circle class is different from all of the other classes you
have seen thus far. It does not have a main method and therefore
cannot be run; it is merely a definition for circle
• The illustration of class templates and objects in can be
standardized using Unified Modeling Language (UML) notation.
This notation is called a UML class diagram, or simply a class
diagram.

7
 Unified Modeling Language (UML) Class
Diagram

In the class diagram, the data field is denoted as

dataFieldName: dataFieldType

The constructor is denoted as:

ClassName(parameterName: parameterType)

The method is denoted as

methodName(parameterName: parameterType): returnType
8
Example: SimpleCircle class

9
Example: SimpleCircle class

10
 Example: SimpleCircle class
• The program contains two classes. The first of these,
TestSimpleCircle, is the main class. Its sole purpose is to test
the second class, SimpleCircle. Such a program that uses the
class is often referred to as a client of the class. When you run
the program, the Java runtime system invokes the main
method in the main class.
• You can put the two classes into one file, but only one class in
the file can be a public class. Furthermore, the public class
must have the same name as the file name. Therefore, the file
name is TestSimpleCircle.java, since TestSimpleCircle is
public.
• Each class in the source code is compiled into a .class file.
When you compile TestSimpleCircle.java, two class files
TestSimpleCircle.class and SimpleCircle.class are generated,
11
Combine Two Classes into One

12
 C
o
m
bi
ne
T
w
o
Cl
as
se
s
int
o
O
ne
13
 Example: Defining Classes and Creating Objects
TV
channel: int The current channel (1 to 120) of this TV.
volumeLevel: int The current volume level (1 to 7) of this TV.
on: boolean Indicates whether this TV is on/off.

The + sign indicates +TV() Constructs a default TV object.

a public modifier.
+turnOn(): void Turns on this TV.
+turnOff(): void Turns off this TV.
+setChannel(newChannel: int): void Sets a new channel for this TV.
+setVolume(newVolumeLevel: int): void Sets a new volume level for this TV.
+channelUp(): void Increases the channel number by 1.
+channelDown(): void Decreases the channel number by 1.
+volumeUp(): void Increases the volume level by 1.
+volumeDown(): void Decreases the volume level by 1.

The constructor and methods in the TV class are

defined public so they can be accessed from other
classes.
14
Example: Defining Classes and Creating Objects

15
Example: Defining Classes and Creating Objects

16
 Visibility Modifiers and Accessor/Mutator
Methods
• You can use the public visibility modifier for classes, methods,
and data fields to denote that they can be accessed from any
other classes.
• If no visibility modifier is used, then by default the classes,
methods, and data fields are accessible by any class in the same
package. This is known as package-private or package-access.
• Packages can be used to organize classes. To do so, you need to
add the following line as the first statement in the program:
package packageName;
• If a class is defined without the package statement, it is said to be
placed in the default package.

17
 Access Specifiers

By default, the class, variable, or method can be

accessed by any class in the same package.

 public
• The class, data, or method is visible to any class in any
package.
 private
• The data or methods can be accessed only by the declaring
class.
• Public getter (Accessor) and setter (Mutator) methods are used
to read and modify private properties.

18
 Examples

• The private modifier restricts access to within a class,

• The default modifier restricts access to within a package,
• The public modifier enables unrestricted access.
19
 Access specifiers

• The default modifier on a class restricts access to within a

package
• The public modifier enables unrestricted access.
• The protected access level has a scope that is within the
package. A protected entity is also accessible outside the
package through inherited class or child class.
20
 NOTE

• An object cannot access its private members, as shown in (b). It

is OK, however, if the object is declared in its own class, as
shown in (a).

21
 NOTE

• The private modifier applies only to the members of a class.

The public modifier can apply to a class or members of a class.
Using the modifiers public and private on local variables
would cause a compile error.

• In most cases, the constructor should be public. However, if you

want to prohibit the user from creating an instance of a class,
use a private constructor. For example, there is no reason to
create an instance from the Math class, because all of its data
fields and methods are static. To prevent the user from creating
objects from the Math class, the constructor in java.lang.Math
is defined as private.

22
 NOTE
Outside
Access Inside Outside
Inside Class package
Specifier Package package
subclass
Private Yes No No No
Default Yes Yes No No
Protected Yes Yes Yes No
Public Yes Yes Yes Yes

23
 Non-access specifiers
7 Non-access modifiers/ specifiers :

1. Static
2. Final
3. Abstract
4. Synchronized
5. Transient
6. Strictfp
7. Native

24
 Non-access specifiers
Final non-access modifier:
This modifier can be applied with:
• Class
• Method
• Instance Variable
• Local Variable
• Method arguments
Final:
final class Honda{
public final void myFun1(){
System.out.println("Honda Class");
}}
class Bike extends Honda{
public void myFun1(){
System.out.println("Bike Class");
}
25
}
 Non-access specifiers
Abstract:
Abstract keyword is used to declare a class as partially
implemented means an object cannot be created directly from
that class. Any subclass needs to be either implement all the
methods of the abstract class, or it should also need to be an
abstract class.
• Abstract class
• Abstract method

Synchronized:
This keyword helps prevent the access of one method by
multiple threads simultaneously, thus synchronizing the flow
of a program and bringing out the desired results using the
multithreading feature.
26
 Non-access specifiers

Synchronized:
Example:
class Person1 {
public synchronized void sendFun(String txt) {
System.out.println("Sending message\t" + txt );
try {
Thread.sleep(1000);
}
catch (Exception e) {
System.out.println("Thread interrupted.");
}
System.out.println("\n" + txt + "Sent");
}
}
27
 Non-access specifiers

class DemoThread extends Thread {

private String txt;
Person1 person;
DemoThread(String m, Person1 obj)
{
txt = m; person = obj;
}
public void run() {
synchronized(person) {
person.sendFun(txt);
}
}
}

28
 Non-access specifiers

public class HelloWorld {

public static void main(String args[]) {
Person1 snd = new Person1();
DemoThread S1 = new DemoThread( " Hi " , snd );
DemoThread S2 = new DemoThread( " Bye " , snd );
S1.start();
S2.start(); // wait for threads to end
try {
S1.join();
S2.join();
}
catch(Exception e) {
System.out.println("Interrupted");
}
} 29
 Non-access specifiers

Static:
This variable is used for memory management and the first
thing being referenced while loading a class. These members
are treated on a class level; thus, they cannot be called using an
object; instead, the name of the class is used to refer to them.
Can be used in:
• Variables
• Classes
• Methods
• Blocks

30
 Non-access specifiers

Static:
Example:
public class Demo {
// static variable
static int x = 10;
static int y;
//static class
public static class DemoInnerClass{
static int z=10;
}
// static block
static {
System.out.println("Static block initialized.");
y = x + 4;
}
31
 Non-access specifiers

//static method
public static void main(String[] args)
{
System.out.println("from main");
System.out.println("Value of x : "+x);
System.out.println("Value of y : "+y);
System.out.println("Value of z : "+DemoInnerClass.z);
}
}

32
 Non-access specifiers

Native:
The native keyword is used only with the methods to indicate
that the particular method is written in platform -dependent.
These are used to improve the system’s performance, and the
existing legacy code can be easily reused.
Note: Static, as well as abstract methods, cannot be declared as
native.

33
 Non-access specifiers

Native:
Example:
import java.io.*; 
class Main
{
    public native void printMethod (); 
    static{
             System.loadLibrary ("LibraryName");  
    }
    public static void main (String[] args)
    {
        Main obj = new Main ();
        obj.printMethod ();
    }
} 34
 Non-access specifiers

Strictfp class/method:
This keyword is used to ensure that results from an operation on
floating-point numbers brings out the same results on every platform.
This keyword can not be used with abstract methods, variables or
constructors as these need not contain operations.
Example:
public class HelloWorld {
public strictfp double calSum() {
double n1 = 10e+07;
double n2 = 9e+08;
return (n1+n2);
}
public static strictfp void main(String[] args) {
HelloWorld t = new HelloWorld ();
System.out.println("Result is -" + t.calSum());
}} 35
 Non-access specifiers

Transient:
While transferring the data from one end to another over a network,
it must be serialised for successful receiving of data, which means
convert to byte stream before sending and converting it back at
receiving end. To tell JVM about the members who need not undergo
serialization instead of being lost during transfer, a transient modifier
comes into the picture.
Syntax:
private transient member1;

Non-access modifiers are the type of modifiers that tell JVM about
the behavior of classes, methods, or variables defined and prepared
accordingly. It also helps in synchronizing the flow as well as
displaying similar results from operations being performed
irrespective of the platform used for execution.
36
 Declaring Object Reference Variables

• Objects are accessed via the object’s reference variables, which

contain references to the objects.
• To reference an object, assign the object to a reference variable.
• A class is a reference type, which means that a variable of the
class type can reference an instance of the class.
• To declare a reference variable, use the syntax:
ClassName objectRefVar;
Example:
Circle myCircle;

37
 Declaring/Creating Objects
in a Single Step

ClassName objectRefVar = new ClassName();

Example:
Circle myCircle = new Circle();

38
 Accessing Object’s Members

 Referencing the object’s data is done using the dot

operator or object member access operator:
objectRefVar.data
e.g., myCircle.radius

 Invoking the object’s method:

objectRefVar.methodName(arguments)
e.g., myCircle.getArea()

39
 Trace Code
Declare myCircle

Circle myCircle = new Circle(5.0); myCircle no value

Circle yourCircle = new Circle();

yourCircle.radius = 100;

40
 Trace Code

Circle myCircle = new Circle(5.0); myCircle no value

Circle yourCircle = new Circle();

: Circle
yourCircle.radius = 100; radius: 5.0

Create a circle

41
 Trace Code

Circle myCircle = new Circle(5.0);

myCircle reference value
Circle yourCircle = new Circle();

yourCircle.radius = 100; Assign object reference : Circle

to myCircle
radius: 5.0

42
 Trace Code
Circle myCircle = new Circle(5.0);
myCircle reference value
Circle yourCircle = new Circle();

yourCircle.radius = 100; : Circle

radius: 5.0

yourCircle no value

Declare yourCircle

43
 Trace Code
Circle myCircle = new Circle(5.0);
myCircle reference value
Circle yourCircle = new Circle();

yourCircle.radius = 100; : Circle

radius: 5.0

yourCircle no value

: Circle
Create a new radius: 1.0
Circle object

44
 Trace Code
Circle myCircle = new Circle(5.0);
myCircle reference value
Circle yourCircle = new Circle();

yourCircle.radius = 100; : Circle

radius: 5.0

yourCircle reference value

Assign object reference

to yourCircle : Circle

radius: 1.0

45
 Trace Code
Circle myCircle = new Circle(5.0);
myCircle reference value
Circle yourCircle = new Circle();

yourCircle.radius = 100; : Circle

radius: 5.0

yourCircle reference value

: Circle
Change radius in
radius: 100.0
yourCircle

46
 Caution

• The data field radius is referred to as an instance variable, because

it is dependent on a specific instance. For the same reason, the
method getArea is referred to as an instance method, because you
can invoke it only on a specific instance.
• The object on which an instance method is invoked is called a
calling object.

47
 Caution

• Recall that you use

Math.methodName(arguments) (e.g., Math.pow(3, 2.5))
to invoke a method in the Math class. Can you invoke getArea() using
SimpleCircle.getArea()? The answer is no.

• getArea() is non-static. It must be invoked from an object using

objectRefVar.methodName(arguments) (e.g., myCircle.getArea()).

48
 Reference Data Fields
The data fields can be of reference types. For example, the
following Student class contains a data field name of the String
type.

public class Student {

String name; // name has default value null
int age; // age has default value 0
boolean isScienceMajor; // isScienceMajor has default value false
char gender; // c has default value '\u0000'
}

49
 The null Value

If a data field of a reference type does not reference any object, the
data field holds a special literal value, null.

50
 Default Value for a Data Field
The default value of a data field is null for a reference type, 0 for a
numeric type, false for a boolean type, and '\u0000' for a char type.
However, Java assigns no default value to a local variable inside a
method.

public class Test {

public static void main(String[] args) {
Student student = new Student();
System.out.println("name? " + student.name);
System.out.println("age? " + student.age);
System.out.println("isScienceMajor? " + student.isScienceMajor);
System.out.println("gender? " + student.gender);
}
}
51
 Example

Java assigns no default value to a local variable inside a method.

public class Test {

public static void main(String[] args) {
int x; // x has no default value
String y; // y has no default value
System.out.println("x is " + x);
System.out.println("y is " + y);
}
}
Compile error: variable not initialized

52
 Differences between Variables of
Primitive Data Types and Object Types

• Every variable represents a memory location that holds a

value. When you declare a variable, you are telling the
compiler what type of value the variable can hold. For a
variable of a primitive type, the value is of the primitive
type. For a variable of a reference type, the value is a
reference to where an object is located.

53
Copying Variables of Primitive Data Types and Object Types

54
 Garbage Collection

As shown in the previous figure, after the assignment statement c1

= c2, c1 points to the same object referenced by c2. The object
previously referenced by c1 is no longer referenced. This object is
known as garbage. Garbage is automatically collected by JVM.

TIP: If you know that an object is no longer needed, you can

explicitly assign null to a reference variable for the object. The
JVM will automatically collect the space if the object is not
referenced by any variable.

55
 The Date Class
Java provides a system-independent encapsulation of date and time in
the java.util.Date class. You can use the Date class to create an instance
for the current date and time and use its toString method to return the
date and time as a string.

56
The Date Class Example

57
 The Random Class
You have used Math.random() to obtain a random double value
between 0.0 and 1.0 (excluding 1.0). A more useful random number
generator is provided in the java.util.Random class.

java.util.Random
+Random() Constructs a Random object with the current time as its seed.
+Random(seed: long) Constructs a Random object with a specified seed.
+nextInt(): int Returns a random int value.
+nextInt(n: int): int Returns a random int value between 0 and n (exclusive).
+nextLong(): long Returns a random long value.
+nextDouble(): double Returns a random double value between 0.0 and 1.0 (exclusive).
+nextFloat(): float Returns a random float value between 0.0F and 1.0F (exclusive).
+nextBoolean(): boolean Returns a random boolean value.

58
 The Random Class Example
If two Random objects have the same seed, they will generate identical
sequences of numbers. For example, the following code creates two
Random objects with the same seed 3.

Random random1 = new Random(3);

System.out.print("From random1: ");
for (int i = 0; i < 10; i++)
System.out.print(random1.nextInt(1000) + " ");
Random random2 = new Random(3);
System.out.print("\nFrom random2: ");
for (int i = 0; i < 10; i++)
System.out.print(random2.nextInt(1000) + " ");
From random1: 734 660 210 581 128 202 549 564 459 961
From random2: 734 660 210 581 128 202 549 564 459 961

59
 The Point2D Class
Java API has a conveninent Point2D class in the javafx.geometry
package for representing a point in a two-dimensional plane.

60
The Point2D Class

61
 Passing Objects to Methods

• Passing by value for primitive type value (the value is

passed to the parameter)
• Passing by value for reference type value (the value is the
reference to the object)

62
Passing Objects to Methods

63
Passing a primitive type value and a reference value

64
 Passing a primitive type value and a reference value

When passing an argument of a reference type, the reference of the object is

passed. In this case, c contains a reference for the object that is also referenced
via myCircle. Therefore, changing the properties of the object through c inside
the printAreas method has the same effect as doing so outside the method through
the variable myCircle. Pass-by-value on references can be best described
semantically as pass-by-sharing; that is, the object referenced in the method is the
same as the object being passed.

65
Passing Objects to Methods

66