Lecture 9 Class and Objects

Maharaja Agrasen Institute of
Technology
CIC-212
Java Programming
Lecture
Classes and Objects
Classes and Objects
A class consists of variables
called fields together with
functions called methods or
member functions that act on
those fields.
General Structure of a Class
Members of a class are:
• fields or variables
– a class or object's state or attributes
• methods
– a class or object's behaviour
• constructors
– to make objects
• each has access control
Types of Members
• fields or variables
– instance unique values for each object
– class uses the static modifier
same value for all objects
• methods
– instance work with both instance
and static variables
– class uses static modifier
works with static variables
Fields or Variables
 field or variable holds a single value
 is strongly typed: must be declared
 type specifies the kind of value and the variable's
behaviour
 int i = 123; // integer primitive
 Point pt = null; // object reference
 pt = new Point (x, y); // coordinates
pt has the value of the Point object's address, not
the x, y coordinates
Classes and Objects
A class is a collection of fields (data) and methods
(procedure or function) that operate on that data.
Circle
centre
radius
circumference()
area()
Classes and Objects
• A class is a collection of fields (data) and methods
(procedure or function) that operate on that data.
• The basic syntax for a class definition:
class ClassName [extends
SuperClassName]
{
[fields declaration]
[methods declaration]
}
• Bare bone class – no fields, no methods
public class Circle {

// my circle class
}
Classes and Objects
Adding Fields: Class Circle with fields
• Add fields

public double x, y; // centre coordinate
public double r; // radius of the circle
• The fields (data) are also called the instance

variables.
Classes and Objects
Adding Methods
• A class with only data fields has no life. Objects
created by such a class cannot respond to any
messages.
• Methods are declared inside the body of the class
but immediately after the declaration of data fields.
• The general form of a method declaration is:
type MethodName (parameter-list)

{
Method-body;
}
Classes and Objects
Adding Methods to Class Circle
public double x, y; // centre of the circle

public double r; // radius of circle
//Methods to return circumference and area

public double circumference() {
return 2*3.14*r;
}
public double area() { Method Body
return 3.14 * r * r;
}
}
Classes and Objects
Data Abstraction
• Declare the Circle class, have created a new
data type – Data Abstraction
• Can define variables (objects) of that type:
Circle aCircle;
Circle bCircle;
Classes and Objects
Class of Circle cont.
• aCircle, bCircle simply refers to a Circle
object, not an object itself.
aCircle bCircle
null null
Points to nothing (Null Reference) Points to nothing (Null Reference)

Classes and Objects
Creating objects of a class
• Objects are created dynamically using the new
keyword.
• aCircle and bCircle refer to Circle objects
aCircle = new Circle() ; bCircle = new Circle() ;

Classes and Objects
aCircle = new Circle();
bCircle = new Circle() ;
bCircle = aCircle;
Classes and Objects
aCircle = new Circle();
bCircle = new Circle() ;
bCircle = aCircle;
Before Assignment Before Assignment
aCircle bCircle aCircle bCircle
P Q P Q
Classes and Objects
Automatic garbage collection
• The object
Q
does not have a reference and
cannot be used in future.
• The object becomes a candidate for automatic

garbage collection.
• Java automatically collects garbage periodically

and releases the memory used to be used in the
future.
Classes and Objects
Accessing Object/Circle Data
• Similar to C syntax for accessing data defined
in a structure.
ObjectName.VariableName
ObjectName.MethodName(parameter-list)
Circle aCircle = new Circle();
aCircle.x = 2.0 // initialize center and radius

aCircle.y = 2.0
aCircle.r = 1.0
Classes and Objects
Executing Methods in Object/Circle
• Using Object Methods:
sent ‘message’ to aCircle
Circle aCircle = new Circle();
double area;
aCircle.r = 1.0;
area = aCircle.area();
Classes and Objects
Using Circle Class
// Circle.java: Contains both Circle class and its user class
//Add Circle class code here
class MyMain
{
public static void main(String args[])
{
Circle aCircle; // creating reference
aCircle = new Circle(); // creating object
aCircle.x = 10; // assigning value to data field
aCircle.y = 20;
aCircle.r = 5;
double area = aCircle.area(); // invoking method
double circumf = aCircle.circumference();
System.out.println("Radius="+aCircle.r+" Area="+area);
System.out.println("Radius="+aCircle.r+" Circumference ="+circumf);
}
}
[raj@mundroo]%: java MyMain
Radius=5.0 Area=78.5
Radius=5.0 Circumference =31.400000000000002
Constructors
• a special kind of method to construct an instance
of an object from a class template
• default constructor is ClassName()
– created if the class has no constructors
• instance fields are initialized to default values
automatically (see next slide)
• overloaded constructors: same name with
different parameter lists
• use of “this” to call another constructor
Constructors
Java automatically initializes class (static) and object
(instance) fields
Primitive Data Type Default Value

boolean false
int, etc. 0
Object Reference Type null

- not yet referring to an object
Constructors
Constructors
this keyword
Referencing the current object
To call another constructor
Constructors
Constructor initializes an object's instance fields
class MyClass {
int maximum;
int counter;
boolean isBelowMax = true; // override default
MyClass(int maximum) {
this.maximum = maximum;
}
MyClass() { this(100); } // calls this class's constructor
MyClass(int maximum, int counter) {

this.maximum = maximum; // assign local field value
this.counter = counter; // to this object's instance
isBelowMax = counter < maximum;
}
Method Overloading
• overloading is supported:
same method name, different parameter lists
• parameters passed by value, i.e. by copy

– primitive data types and object reference types
– copy of object reference is not a copy of the object
• type of primitive/object returned or void

Classes and Objects
Four Levels of Access to a Class or object's
members
private: accessible from within this class only
 should be standard practice on instance fields
to support OO encapsulation
default (if you don't specify):
accessible from any class in the package
protected: accessible from any subclass or any class in
the package
public: accessible from any class anywhere
Static keyword
When objects of its class are declared, no copy of a static
variable is made
 Instead, all instances of the class share the same static variable
When a member is declared static, it can be accessed before
any objects of its class are created, and without reference to any
object
The most common example of a static member is main().
 Outside of the class in which static methods are defined, static
methods and variables can be used independently of any object.
To do so, you need only specify the name of their class
followed by the .(dot) operator
ClassName.methodName()
Static keyword
Restrictions:
1. Static methods can only call other static methods.

2. They can only access static data.
3. They can not refer to ‘this’ or ‘super’ in any way.
Static Blocks
• Static block is a block of code prefixed by ‘static’ keyword
• Gets executed only once
• Used to initialize static variables
class A {
static int x;
static {
x = 10; static block
initializes
} x to 10
public static void main (String args[])

{
System.out.println (“ x value is : ”+ x);
}
Output : x value is : 10
}
Example Program : Static Block
class A {
static int x = 10;
static int y; Output
static void call( int p) { x value is : 10
System .out. println(“ x value is :”+x); y value is : 20
System .out .println(“ y value is :”+y); p value is : 30
System .out .println(“ p value is :”+p);
}
static {
System.out.println(“ static block initialized”);
y=x*2;
}
public static void main (String args[]) {
call(30);
}
}
Final keyword
A variable can be declared as final
Doing so prevents its contents from being modified
This means that you must initialize a final variable

when it is declared
Permits us to create typed constants
 In usage, final is similar to const in C / C++

Example final variables
Syntax
final type constName = value;
Example
final int FILE_NEW = 1;
final float PI = 3.141519;
Final Variables
Subsequent parts of the program may use the above
final variables FILE_NEW and PI
It is common coding convention to choose all uppercase

identifiers for final variables
Variables declared as final do not occupy memory on a

per-instance basis
Thus, a final variable is essentially a constant

Example program : final variables
Correct program Wrong program
class A { class B {
final int X = 10; final int X = 10;
public static void main (String args[]) public static void main(String args[]) {
{ X = 20;
System.out.println(“ X is “+X); System .out. println(“ X is “+X);
} }
} }
final variable
should not change
Other Uses Of final
The keyword final can also be applied to

methods,
Its meaning is substantially different than when it
is applied to variables
Varargs
 Newly implemented feature in Java 5.0

 Basic syntax
type … variableName
 Argument passed to a method is converted
into an array of the same-typed values
sum (10,20) sum(new int[] {10,20})
Varargs
Example
public static void main(String[] args)
{
System.out.println(“The sum is ” + sum(10,20,30));
}
public int sum (double … numbers)
{
int total = 0;
for (int i = 0; i < numbers.length; i++)
total += numbers[i];
return total;
} OUTPUT:
The sum is 60
Varargs
• Varargs is done with the … operator.
• Example. The following constructor

public Person (String name, String details… )
Can be called with many different invocations:
new Person (“Alexander ”);

new Person (“Alexander ”, “Bell ”);
new Person (“Alexander ”,”Graham”, “Bell ”);

Lecture 9 Class and Objects

Uploaded by

Copyright:

Available Formats

Lecture 9 Class and Objects

Uploaded by

Document Information

Original Description:

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Lecture 9 Class and Objects

Uploaded by

Copyright:

Available Formats

Maharaja Agrasen Institute of

public class Circle {

public class Circle {

• The fields (data) are also called the instance

type MethodName (parameter-list)

public double x, y; // centre of the circle

//Methods to return circumference and area

• Can define variables (objects) of that type:

Points to nothing (Null Reference) Points to nothing (Null Reference)

aCircle = new Circle() ; bCircle = new Circle() ;

Before Assignment Before Assignment

aCircle bCircle aCircle bCircle

• The object becomes a candidate for automatic

• Java automatically collects garbage periodically

Circle aCircle = new Circle();

aCircle.x = 2.0 // initialize center and radius

Circle aCircle = new Circle();

Primitive Data Type Default Value

Object Reference Type null

MyClass() { this(100); } // calls this class's constructor

MyClass(int maximum, int counter) {

• parameters passed by value, i.e. by copy

• type of primitive/object returned or void

1. Static methods can only call other static methods.

public static void main (String args[])

Doing so prevents its contents from being modified

This means that you must initialize a final variable

Permits us to create typed constants

 In usage, final is similar to const in C / C++

It is common coding convention to choose all uppercase

Variables declared as final do not occupy memory on a

Thus, a final variable is essentially a constant

The keyword final can also be applied to

 Newly implemented feature in Java 5.0

• Example. The following constructor

Can be called with many different invocations:

new Person (“Alexander ”);

You might also like