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”);
• SsetName(“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
