CSE215 Chapter 9 Objects-And-classes
CSE215 Chapter 9 Objects-And-classes
1
OO Programming in Java
Other than primitive data types (byte, short, int, long, float, double, char,
boolean), everything else in Java is of type object.
2
What is an Object?
An object represents an entity in the real world that can be distinctly
identified. For example, student, desk, circle, button, person, course,
etc…
For instance, an object might represent a particular employee in a
company. Each employee object handles the processing and data
management related to that employee.
An object has a unique identity, state, and behaviors.
The state of an object consists of a set of data fields (instance variables
or properties) with their current values.
The behavior of an object is defined by a set of methods defined in the
class from which the object is created.
A class describes a set of similar objects.
3
Object Representation
In OO programming (e.g., Java), an object is associated with a memory
space referenced by the object name.
The memory space is allocated when using the new operator to create
the object.
The memory space holds the values of the data fields (instance
variables) of the object.
4
What is a Class?
A class is the blueprint (template) that defines objects of the
same type, a set of similar object, such as students.
The class uses methods to define the behaviors of its objects.
The class that contains the main method of a Java program
represents the entire program
A class provides a special type of methods, known as
constructors, which are invoked to construct (create) objects
from the class.
Multiple objects can be created from the same class.
Example
A class An object
(the concept) (the realization)
Multiple objects
from the same class
Writing Classes
The programs we’ve written in previous examples have used
classes defined in the Java standard class library.
Now, we will begin to design programs that rely on classes that
we write ourselves.
The class that contains the main method is just the starting
point of a program.
Writing Classes
A class can contain data declarations and method declarations.
BankAccount
String ownerName;
double balance; Data declarations
Deposit()
CheckBalance()
Another Example
Fig 9.2
9
Circle Class
11
Constructor Methods
The constructor method creates the object in the memory with the
help of the Operating System.
Constructors are invoked using the new operator when an object is
created. Constructors play the role of initializing objects.
A class can have multiple versions of the constructor method,
allowing the user to create the class object in different ways.
The constructor method must have same name as the class name.
Constructors do not have a return type, not even void.
A constructor with no parameters is called no-arguments
constructor.
12
Class Circle Constructors
class Circle {
// The radius of this circle
double radius = 1.0; Data field
Example:
Circle myCircle1, myCircle2; //reference variables
myCircle1 = new Circle(); //calls first constructor
myCircle2 = new Circle(5.0); //calls second constructor
OR
Circle myCircle1 = new Circle();
Circle myCircle2 = new Circle(5.0);
14
Default Constructor
15
Overloaded Constructors
Like regular methods, constructors can be
overloaded (i.e., multiple constructors can have the
same name but different signatures), making it easy
to construct objects with different initial data values
Accessing the Object
Referencing the object’s data:
objectRefVar.data
17
animation
Trace Code
Declare myCircle
yourCircle.radius = 100;
18
animation
Trace Code, cont.
radius: 5.0
Create a circle
19
animation
Trace Code, cont.
20
animation
Trace Code, cont.
Circle myCircle = new Circle(5.0); reference value
myCircle
Circle yourCircle = new Circle();
radius: 5.0
yourCircle no value
Declare yourCircle
21
animation
Trace Code, cont.
Circle myCircle = new Circle(5.0); reference value
myCircle
Circle yourCircle = new Circle();
radius: 5.0
yourCircle no value
: Circle
Create a new radius: 0.0
Circle object
22
animation
Trace Code, cont.
Circle myCircle = new Circle(5.0); reference value
myCircle
Circle yourCircle = new Circle();
radius: 5.0
radius: 1.0
23
animation
Trace Code, cont.
Circle myCircle = new Circle(5.0); reference value
myCircle
Circle yourCircle = new Circle();
radius: 5.0
: Circle
Change radius in radius: 100.0
yourCircle
24
Caution
Recall that we used
Math.methodName(arguments)
(e.g., Math.pow(3, 2.5))
25
Reference Data Fields
The data fields can be of reference types.
If a data field of a reference type does not reference any object, the
data field holds a special literal value null (or null pointer) .
For example, Class Student contains a data field name of the type
String (an array of characters).
26
Default Value for a Data Field
27
Default Values Inside Methods
Rule: Java assigns no default values to local variables inside a
method. A method's local variables must be initialized.
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);
}
}
28
Primitive Type vs. Object Type
radius = 1
29
Primitive Type vs. Object Type
Primitive type assignment i = j
Before: After:
i 1 i 2
j 2 j 2
c1 c1
c2 c2
30
Garbage Collection
On the previous slide, after the assignment statement
c1 = c2; //circle objects
31
Static Variables, Constants, and Methods
32
Static Variables, Constants, and Methods
instantiate
circle1 Memory
33
Static and Instance Method Differences
This works!
Visibility Modifiers
By default, a class variable or method can be
accessed by any class in the same package, but not
other packages.
Public:
The class, data, or method is visible to any class in any package.
Private:
The data or method can be accessed only by the declaring class.
The get and set methods are used to read and modify private
variables (better security).
Protected:
The methods or data members declared as protected are accessible
within the same package or subclasses in different packages. It is
specified using the keyword protected 35
Visibility Modifiers Example - 1
37
Data Field Encapsulation
Encapsulation is the idea of hiding the class internal details that are not
required by clients/users of the class.
Why? To protect data and to make classes easy to maintain and update.
How? Always use private variables!
Circle
The - sign indicates
private modifier - radius: double The radius of this circle (default: 1.0).
- numberOfObjects: int The number of circle objects created (static).
38
Visibility Modifiers - Comments - 1
Class members (variables or methods) that are declared with public
visibility can be referenced/accessed anywhere in the program.
39
Visibility Modifiers - Comments - 2
Methods that provide the object's services must be declared with
public visibility so that they can be invoked by clients (users of
the object).
40
Example - 1
public class CircleWithPrivateDataFields
{
private double radius = 1;
private static int numberOfObjects = 0;
41
public class TestCircleWithPrivateDataFields {
Output:
43
public class TestPassObject {
45
Array of Objects
46
Example
public class TotalArea {
public static void main(String[] args) {
// next slide
47
//Print an array of circles and their total area
public static void printCircleArray(
CircleWithPrivateDataFields[] circleArray)
{
System.out.println("Radius" + "\t\t\t\t" + "Area");
for (int i = 0; i < circleArray.length; i++) {
System.out.println(circleArray[i].getRadius() + "\t\t" +
circleArray[i].getArea());
}
System.out.println("-----------------------------------------");
//Compute and display the result
System.out.println("The total areas of circles is\t" +
sum(circleArray));
}
Radius Area
0.049319 0.007642
81.879485 21062.022854
95.330603 28550.554995
92.768319 27036.423936
46.794917 6879.347364
-----------------------------------------
The total areas of circles is 83528.356790
49
Immutable Objects and Classes
If the contents of an object cannot be changed once it is created, the
object is called an immutable object and its class is called an
immutable class.
For example, If you delete the set method in the Circle class in
Listing 8.10, the class would be immutable (not changeable)
because radius is private and cannot be changed without a set
method.
A class with all private data fields and without mutators (set
methods) is not necessarily immutable. For example, the following
class Student has all private data fields and no mutators, but it is
mutable (changeable).
50
Immutable Object Example
public class Student {
public class BirthDate {
private int id;
private int year;
private BirthDate birthDate;
private int month;
private int day;
public Student(int ssn,
int year, int month, int day) {
public BirthDate(int newYear,
id = ssn;
int newMonth, int newDay) {
birthDate = new BirthDate(year,
year = newYear;
month, day);
month = newMonth;
}
day = newDay;
}
public int getId() { return id; }
public void setYear(int newYear)
public BirthDate getBirthDate() {
return birthDate;
{ year = newYear; }
}
}
}
52
Scope of Variables - Revisited
53
The this Keyword
The this keyword is the name of a reference that refers to
an object itself. One common use of this keyword is
referencing a class’s hidden data fields.
54
Referencing the Hidden Data Fields
public class F { Suppose that f1 and f2 are two objects of F.
private int i = 5; F f1 = new F(); F f2 = new F();
private static double k = 0;
Invoking f1.setI(10) is to execute
void setI(int i) { this.i = 10, where this refers f1
this.i = i;
} Invoking f2.setI(45) is to execute
this.i = 45, where this refers f2
static void setK(double k) {
F.k = k;
}
}
55
Calling Overloaded Constructors
public class Circle {
private double radius;
Output:
Sat Nov 08 12:31:11 EST 2014
57
End of Chapter 9
58