Java Class and Objects

Calling Methods Calling Methods

pass the value of i
pass the value of j
public static void main(String[] args) {
int i = 5;
int j = 2;
int k = max(i, j);

System.out.println(
public static int max(int num1, int num2) {
int result;

if (num1 > num2)
result = num1;
else
"The maximum between " + i +
" and " + j + " is " + k);
}
result = num2;

return result;
}
2
Object Oriented Programming Object Oriented Programming
Concepts
Objects Objects
An object has a unique identity, state, and behaviors. The state
of an object consists of a set of data fields (also known as
properties) with their current values. The behavior of an object
is defined by a set of methods is defined by a set of methods.
Classes
Classes are constructs that define objects of the
same type same type.
A Java class uses variables to define data fields and
th d t d fi b h i 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
Objects

Class Name: Circle

Data Fields:
radius is _______
A class template
Methods:
getArea
Circle Object 1

Data Fields:
radius is 10
Circle Object 2

Data Fields:
radius is 25
Circle Object 3

Data Fields:
radius is 125
Three objects of
the Circle class
An object has both a state and behavior. The
state defines the object, and the behavior
defines what the object does.
6
Instance and Class variables
Instance variable are those variables that are associated
with each object uniquely.
Each instance of the class will have its own copy of each of these variables.
Each object will have its own values for each instance variables that
differentiate one object from the other of the same class type.
Declared in the usual way and can have an initial value specified.
Class variables are associated with the class and is shared
b ll bj t f th l by all objects of the class.
There is only one copy of each of these variables no matter how many class
objects are created.
They exist even if no objects of class have been created.
These variables are also called static fields because we use the keyword static
when we declare them when we declare them.
Instance and Class Methods
Instance Methods
These methods can only be executed in relation to a particular object
If no object exists, no instance method can be executed
Note: Although instance methods are specific to objects of a class, there is only
one copy of an instance method in memory that is shared by all the objects of py y y j
the class.
Class Methods
You can execute class methods even when no objects of a class exist.
Like class variables, these are declared using the keyword static, so also called
static methods
Static methods cannot refer to instance variables or call instance methods.
Why?
Why main is always declared static? Why main is always declared static?
Instance Variables
public class StudentRecord {
// I t i bl // Instance variables
private String name;
private int age; private int age;
private double mathGrade;
private double englishGrade;
private double average;
//we'll add more code here later
}}
Declare instance variables as private so that only
class methods can access them directly.
Class (static) variables
public class StudentRecord {
//static variables
private static int studentCount;
//we'll add more code here later
}
we use the keyword static to indicate that a variable is a static
variable.
Accessor (Getter) Method
public class StudentRecord {
private String name;
// some code
// An example in which the business logic is
// used to return a value on an accessor method
public double getAverage(){
double result = 0;
result=(mathGrade+englishGrade+scienceGrade)/3; result=(mathGrade+englishGrade+scienceGrade)/3;
return result;
}
}
Mutator (Setter) Method
public class StudentRecord {
private String name;
public void setName( String temp ){
name = temp;
}
}
Static methods
public class StudentRecord {
i t t ti i t t d tC t private static int studentCount;
public static int getStudentCount(){ public static int getStudentCount(){
return studentCount;
}
}
static-means that the method is static and should be
called by typing,[ClassName].[methodName]. called by typing,[ClassName].[methodName].
For example, in this case, we call the method
StudentRecord.getStudentCount()
When to Define Static Method?
When the logic and state does not involve specific object
instance
Computation method
dd(i t i t ) th d add(int x, int y) method
When the logic is a convenience without creating an
object instance object instance
Integer.parseInt();
Example
public class StudentRecord {
// Instance variables
i S i
public String getName(){
return name;
}
private String name;
private String address;
private int age;
public void setName( String temp ) {
name = temp;
}
private double mathGrade;
private double englishGrade;
private double scienceGrade
public double getAverage(){
double result = 0;
result =(mathGrade+englishGrade+scienceGrade )/3;
private double scienceGrade;
private double average;
private static int studentCount;
return result;
}
p blic static int getSt dentCo nt(){ public static int getStudentCount(){
return studentCount;
}
Sample Source Code that uses
StudentRecord Class
public class StudentRecordExample
{
public static void main( String[] args ){ p ( g[] g ){
//create three objects for Student record
StudentRecord aRecord = new StudentRecord();
StudentRecord bRecord = new StudentRecord();
StudentRecord cRecord = new StudentRecord(); StudentRecord cRecord = new StudentRecord();
//set the name of the students
aRecord.setName(BIT");
bRecord.setName(NIIT"); ( );
cRecord.setName(SEECS");
//print name
System.out.println( aRecord.getName() );
// b f d //print number of students
System.out.println("Count="+StudentRecord.getStudentCount());
}
}}
Output Output
BIT
Count=0
An example class-2
public class BankAccount { public class BankAccount {
//--instance variables
private String ID;
private double balance; private double balance;
// Constructor to initialize the state
public BankAccount(String initID, double initBalance) {
ID = initID; ID initID;
balance = initBalance;
}
// Credit this account by depositAmount // C ed t t s accou t by depos t ou t
public void deposit(double depositAmount) {
balance = balance + depositAmount;
}}
// Debit this account by withdrawalAmount
public void withdraw(double withdrawalAmount) {
balance = balance - withdrawalAmount;
18
}
class BankAccount
public String getID() {
return ID;
}}
public double getBalance() {
return balance;;
}
public String toString( ) { p g g( ) {
return ID + " $" + balance;
}
} // End class BankAccount
19
Sample Messages
BankAccount anAcct = new BankAccount("Moss", 500.00);
anAcct.withdraw(60);
anAcct.deposit(147.35);
20

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

/** Construct a circle object */
Circle() {
}
Data field
}

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

/** Return the area of this circle */
double getArea() {
return radius * radius * 3.14159;
}
Method
}
}
Overloading Methods Overloading Methods
Method overloading
allows a method with the same name but different parameters, to have
different implementations and return values of different types
can be used when the same operation has different
implementations.
Always remember that overloaded methods have the following
properties: properties:
the same method name
different parameters or different number of parameters
return types can be different or the same
Example Example
public void print( String temp ){
S t t i tl ("N " ) System.out.println("Name:" + name);
System.out.println("Address:" + address);
System.out.println("Age:" + age);
}
public void print(double eGrade, double mGrade, double
sGrade) sGrade)
System.out.println("Name:" + name);
System.out.println("Math Grade:" + mGrade);
System.out.println("English Grade:" + eGrade);
System.out.println("Science Grade:" + sGrade);
}}
Example
public static void main( String[] args )
{ StudentRecord aRecord = new StudentRecord(); { ();
aRecord.setName(Ahmed");
aRecord.setAddress(Pakistan");
R d tA (15) aRecord.setAge(15);
aRecord.setMathGrade(80);
aRecord.setEnglishGrade(95.5);
aRecord.setScienceGrade(100); aRecord.setScienceGrade(100);
/
/overloaded methods
aRecord.print( aRecord.getName() );
aRecord.print( aRecord.getEnglishGrade(),
aRecord.getMathGrade(),
aRecord.getScienceGrade());
}}
Output Output
we will have the output for the first call to print,
Name:Ahmed
Address:Pakistan
Age:15
we will have the output for the second call to print, p p
Name:Ahmed
Math Grade:80.0
English Grade:95.5
Science Grade:100.0
Default Constructor (Method) Default Constructor (Method)
The default constructor (no-arg constructor)
is the constructor without any parameters.
If the class does not specify any constructors, then
an implicit default constructor is created an implicit default constructor is created.
Overloading Constructors
Classes can have more than one constructor
All constructors have the same name (the class name) ( )
Each constructor differs from the others in either the
number or types of its arguments yp g
new is used when using a constructor to create a new
object
Overloading Constructor Methods Overloading Constructor Methods
public StudentRecord(){
//some initialization code here }}
public StudentRecord(String temp){
this.name = temp; }
public StudentRecord(String name, String address){
this.name = name;
this.address = address; this.address address;
}
public StudentRecord(double mGrade, double eGrade,double sGrade){
mathGrade = mGrade;
englishGrade = eGrade;
scienceGrade = sGrade;
}
Using Constructors
To use these constructors, we have the following code,
bli t ti id i ( St i [] ){ public static void main( String[] args ){
//create three objects for Student record j
StudentRecord aRecord=new StudentRecord(Ahmed");
StudentRecord bRecord=new StudentRecord(BIT, Pakistan");
StudentRecord cRecord=new StudentRecord(80 90 100); StudentRecord cRecord=new StudentRecord(80,90,100);
//some code here
}
this() constructor call this() constructor call
Constructor calls can be chained, meaning, you can call
another constructor from inside another constructor another constructor from inside another constructor.
We use the this() call for this
There are a few things to remember when using the g g
this() constructor call:
When using the this constructor call IT MUST OCCUR When using the this constructor call, IT MUST OCCUR
AS THE FIRST STATEMENT in a constructor
It can ONLY BE USED IN A CONSTRUCTOR
DEFINITION. The this call can then be followed by any
other relevant statements
Example Example
public StudentRecord(){
this("some string") this("some string");
}
public StudentRecord(String temp){
this.name = temp;
}
public static void main( String[] args )
{{
StudentRecord aRecord = new StudentRecord();
}
this reference this reference
The this reference
refers to current object instance itself
used to access the instance variables shadowed by the parameters.
T h hi f To use the this reference, we type,
this.<nameOfTheInstanceVariable>
You can only use the this reference for instance variables and NOT y
static or class variables
this reference this reference
The this reference is assumed when you call a method from the
same object same object
public class MyClass {
void aMethod() { void aMethod() {
// same thing as this.anotherMethod()
anotherMethod();
}}
void anotherMethod() {
// method definition here...
}
}}
Example
public void setAge( int age ){
this.age = age;
}