OOP in Java

By Muhammad Abu Bakar

OOP in Java
• Java is fundamentally Object-Oriented
• Every line of code you write in Java must be inside a Class
(not counting import directives)

• Clear use of
• Variables
• Methods

• Re-use through “packages”

• Modularity, Encapsulation, Inheritance, Polymorphism

etc
OOP Vocabulary Review
• Classes
• Definition or a blueprint of a userdefined
datatype
• Prototypes for objects

• Objects
• Nouns, things in the world

• Constructor
• Given a Class, the way to create an Object (that
is, an Instance of the Class) and initialize it
Object
• Attributes Anything we can put a
thumb on
• Properties an object has

• Methods
• Actions that an object can do
Defining Classes
 The Structure of Classes
class name {
instance variables
declarations and symbolic constants

constructor how to create and

initialize objects
definitions

how to manipulate
method those objects (may or
definitions may not include its
own “driver”, i.e.,
} These parts of a class can main( ))
actually be in any order
Defining a Class Comparison with C++
• Java gives you the ability to write classes or user-defined data
types similar to the way C++ does, with a few differences

• Points to consider when defining a class

• There are no global variables or functions. Everything

resides inside a class. Remember we wrote our main
method inside a class

• Specify access modifiers (public, private or protected ) for each member

method or data members at every line.
• No semicolon (;) at the end of class
• All methods (functions) are written inline. There are
no separate header and implementation files.
 The Point Class
class Point {
private int x; instance variables
private int y; and symbolic constants

how to create and

public Point (……) initialize objects
{……}

how to manipulate
public void Display
those objects (may or
(……) {
may not include its
………. own “driver”, i.e.,
} main( ))
Defining a Class Comparison with C++ (cont)
• Points to consider when defining a class (cont)

• Automatic initialization of class level data members if you do not

initialize them
• Primitive types
• Numeric (int, float etc) with zero
• Char with null
• Boolean with false

• Object References
• With null
• Remember, the same rule is not applied to local variables. Using a
local variable without initialization is a compile time error.

public void someMethod () {

int x; //local variable
System.out.println(x); //compile time error
}
Defining a Class Comparison with C++ (cont)
• Points to consider when defining a class (cont)

• Access Modifiers
• public : Accessible anywhere by anyone
• Private : Only accessible within this class
• Protected : Accessible only to the class itself and to it’s subclasses or other
classes in the same “package”
• Package : Default access if no access modifier is provided.
Accessible to all classes in the same package
• Constructor
• Same name as class name
• Does not have a return type
• No initialization list
• JVM provides a zero-argument constructor only if a class
doesn’t define it’s own constructor
• Destructor
• Destructors are not required in a java class
Example
 Task - Defining a Class
• Create a class for Student Student
• should be able to store the following
characteristics of student Attributes:
Roll NO
• Roll No Name
• Name Methods:
constructors
• Provide default, parameterized and copy getters/setters
constructors print

• Provide standard getters/setters for instance

variables
• Make sure, roll no has never assigned a negative value i.e.
ensuring the correct state of the object

• Provide print method capable of printing

student object on console
Student Implementation Code
// Student.java
/*
Demonstrates the most basic features of a class. A student is defined by
their name and rollNo. There are standard get/set accessors for name
and rollNo.
NOTE A well documented class should include an introductory comment
like this. Don't get into all the details – just introduce the landscape.
*/
public class Student {
private String Name;
private int RollNo;
Student Implementation Code
cont.
// Standard Setters

public void setName (String name) {

this.Name = name;
}

// Note the masking of class level variable rollNo

public void setRollNo (int rollNo) {
if (rollNo > 0) {
this.RollNo = rollNo;
}else {
this.rollNo = 100;
}
}
Student Implementation Code
cont.

// Standard Getters

public String getName ( ) {

return name;
}

public int getRollNo ( ) {

return rollNo;
}
Student Implementation Code
// Constructor that uses a default value instead of taking an argument.

public Student() {
name = “not set”;
rollNo = 100;
}

// parameterized Constructor for a new student

public Student(String name, int rollNo) {

setName(name); //call to setter of name
setRollNo(rollNo); //call to setter of rollNo
}

// Copy Constructor for a new student

public Student(Student s) {
name = s.name;
rollNo = s.rollNo;
Student Implementation Code
cont.

// method used to display method on console

public void print () {

System.out.println("Student name:" +name+ ", roll no:" +rollNo);
}

} // end of class
Using Classes
Defining a Class Comparison with C++
• Objects of a class are always created on heap using the “new”
operator followed by constructor

• \Student s = new Student () // no pointer operator “*” between

// Student and s

• Only String constant is an exception

• String greet = “Hello” ; // No new operator

• However you can use

• String greet2 = new String(“Hello”);

• Members of a class ( member variables and methods also known as

instance variables/methods ) are accessed using “.” operator. There
is no “” operator in java
• s.setName(“Ali”);
• SsetName(“Ali”) is incorrect and will not compile in java
Differences from C++
(cont)
• Objects are always passed by reference
whereas primitive data types are passed
by value. Using a
• All methods use the run-time, not class
compile-time, types (i.e. all Java
methods are like C++ virtual functions) Comparis
• The types of all objects are known at
on with
run-time C++
• All objects are allocated on the heap
(always safe to return objects from
methods)
Task – Using
Student Class
Student
• Create objects of Student Attributes:
class by calling default, Roll NO
Name
parameterized and copy Methods:
class
constructors
constructors. getters/setters
print

• Call Students class various ali

methods on objects
Attributes:
Roll NO: 89
Name: ali raza
Methods: object
getters/setters
print
Student Client Code
public class Test{

public static void main (String args[]){

// Make two students

Student s1 = new Student("ali", 15);
Student s2 = new Student(); //call to default costructor

s1.print();
s2.print();

s2.setName("usman");
s2.setRollNo(20);

System.out.print("Student name:" + s2.getName());

System.out.println(" rollNo:" + s2.getRollNo());

//continue….
Student Client Code
System.out.println("calling copy constructor");
Student s3 = new Student(s2); //call to copy constructor

s2.print();
s3.print();

s3.setRollNo(-10); //Roll No would be set to 100

s3.print();

/*NOTE: public vs. private

A statement like "b.rollNo = 10;" will not compile in a client
of the Student class when rollNo is declared protected or private */

} //end of main
Compile and Execute
More on Classes
 Static
• A class can have static
• Variables
• Methods

• Static variables and methods

• Are associated with the class itself!!
• Not associated with the object

• Therefore Statics can be accessed without instantiating an

object!

• Generally accessed by class name

• Cannot refer to a non-static instance variable in a static

method
• No this reference
Static Variable & Methods
• Occurs as a single copy in the class
• For example;
• System.out is a static variable
• JOptionPane.showInputDialog(String)
Static Fun
Object: ali
Type: Student
Name: ali raza
Roll No: 5
Methods: getName, setName
getRollNo, setRollNo
toString

Class: Student
countStudents: 2
Method: getCountStudents()
Object: usman
Type: Student
Name: usman shahid
Roll No: 5
Methods: getName, setName
getRollNo, setRollNo
toString
Garbage Collection
• Java performs garbage collection
and eliminates the need to free
objects explicitly.

• When an object has no references

to it anywhere, except in other Garbage
objects that are also unreferenced,
its space can be reclaimed. collection and
finalize
• Before the object is destroyed, it
might be necessary for the object
to perform some actions.
• For example closing an open file. In
such a case define a finalize()
method with the actions to be
performed before the object is
destroyed.
finalize
• When a finalize method is defined in a class, Java run time calls
finalize() whenever it is about to recycle an object of that
class.

protected void finalize()

{
// code
}

• A garbage collector reclaims objects in any order or never

reclaim them.

• System.gc()
• Request the JVM to run the garbage collector
• Not necessary it will run
 Memory Management
Stack Heap
public class Test{
0F59
public static void main|(String args[]){ s1
name
ali
0F59
Student s1 = new Student(“ali”);
Student s2 = new Student(“raza”);
03D2
s1= s2; s2
name
raza
03D2
}

No Memory leakage in Java, Automatic

Garbage Collection will take care of such
scenarios
Example
Modify Student Class
public class Student {
…..
private static int countStudents = 0;

public static int getCountStudents() {

return countStudents;
}

…….
 Modify Student Class
// Constructor that uses a default value instead of taking an argument.

public Student() {
name = “not set”;
rollNo = 100;
countStudents += 1;
}

// parameterized Constructor for a new student

public Student(String name, int rollNo) {
setName(name); //call to setter of name
setRollNo(rollNo); //call to setter of rollNo
countStudents += 1;
}

// Copy Constructor for a new student

public Student(Student s) {
name = s.name;
rollNo = s.rollNo;
countStudents += 1;
}
 Modify Student Class
// Overridden methods

// Overriding toString method of class java.lang.Object

public String toString () {
return ("name: "+name + "RollNo: " + rollNo);
}

//Overriding finalize method of Object class

protected void finalize () {
countStudents -= 1;
}
} // end of class
Student Client Code
public class Test{

public static void main (String args[]){

int numObjs;

numObjs = Student.getCountStudents();
System.out.println("Students Objects:"+numObjs);

Student s1 = new Student("ali", 15);

System.out.println("Student:" + s1.toString() );

numObjs = Student.getCountStudents();
Student Client Code
Student s2 = new Student("usman", 49);
System.out.println("Student:" +s2); //implicit call to toString()

numObjs = Student.getCountStudents();
System.out.println("Students Objects:"+numObjs);

s1 = null;

System.gc(); // request the JVM to run the garbage collector But

// there is no gaurantee that garbage collector will run

numObjs = Student.getCountStudents();
System.out.println("Students Objects:"+numObjs);

} //end of main
Compile and Execute
 More on Java OOP

• http://www.codeguru.com/java/tij/tij_c.shtml