Classes and Nested Classes in Java

Programming in Java
Lecture 5: Objects and Classes
By
Ravi Kant Sahu
Asst. Professor, LPU

Contents
• Class
• Object
• Defining and adding variables
• Nested Classes
• Abstract Class
Ravi Kant Sahu, Asst. Professor @ Lovely Professional University, Punjab (India)

OBJECTS AND CLASS

4
Class
• A class is a collection of fields (data) and methods
(procedure or function) that operate on that data.
Circle
centre
radius
circumference()
area()

What is a class?
• A class can be defined as a template/ blue print that
describe the behaviors/states that object of its type
support.
• A class is the blueprint from which individual objects
are created.
• A class defines a new data type which can be used to
create objects of that type. Thus, a class is a template
for an object, and an object is an instance of a class.

Classes and Objects
• A Java program consists of one or more classes.
• A class is an abstract description of objects.
• Here is an example class:
class Dog { ...description of a dog goes here... }
• Here are some objects of that class:

7
More Objects
• Here is another example of a class:
– class Window { ... }
• Here are some examples of Windows:

• The data, or variables, defined within a class are called
instance variables because each instance of the class (that
is, each object of the class) contains its own copy of these
variables.
• The code is contained within methods.
• The methods and variables defined within a class are
called members of the class.

Defining Classes
 The basic syntax for a class definition:
 Bare bone class – no fields, no methods
public class Circle {
// my circle class
}
class ClassName
{
[fields declaration]
[methods declaration]
}

Adding Fields: Class Circle with fields
• Add fields
• The fields (data) are also called the instance
variables.
public double x, y; // centre coordinate
public double r; // radius of the circle
}

Circle Class
• aCircle, bCircle simply refers to a Circle object, It is
not an object itself.
aCircle
Points to nothing (Null Reference)
bCircle
Points to nothing (Null Reference)
null null

Creating objects of a class
• An object is an instance of the class which has well-
defined attributes and behaviors.
• Objects are created dynamically using the new keyword.
• aCircle and bCircle refer to Circle objects.
bCircle = new Circle();aCircle = new Circle();

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

aCircle = new Circle();
bCircle = new Circle() ;
bCircle = aCircle;
P
aCircle
Q
bCircle
Before Assignment
P
aCircle
Q
bCircle
Before Assignment

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;
}

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() {
return 3.14 * r * r;
}
}
Method Body

Automatic garbage collection
• The object 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.
Q

finalize()
• The finalize() method is declared in the java.lang.Object class.
• Before an object is garbage collected, the runtime system calls
its finalize() method.
• The intent is for finalize() to release system resources such as
open files or open sockets before getting collected.

Accessing Object/Circle Data
Circle aCircle = new Circle();
aCircle.x = 2.0 // initialize center and radius
aCircle.y = 2.0
aCircle.r = 1.0
ObjectName.VariableName
ObjectName.MethodName(parameter-list)

Executing Methods in Object/Circle
• Using Object Methods:
Circle aCircle = new Circle();
double area;
aCircle.r = 1.0;
area = aCircle.area();
sent ‘message’ to aCircle

Nested Class
• The Java programming language allows us to define a
class within another class. Such a class is called a nested
class.
Example:
class OuterClass
{
...
class NestedClass
{
...
}
}

Types of Nested Classes
• A nested class is a member of its enclosing class.
• Nested classes are divided into two categories:
– static
– non-static
• Nested classes that are declared static are simply
called static nested classes.
• Non-static nested classes are called inner classes.

Why Use Nested Classes?
• Logical grouping of classes—If a class is useful to only one other
class, then it is logical to embed it in that class and keep the two
together.
• Increased encapsulation—Consider two top-level classes, A and B,
where B needs access to members of A that would otherwise be
declared private. By hiding class B within class A, A's members can
be declared private and B can access them. In addition, B itself can
be hidden from the outside world.
• More readable, maintainable code—Nesting small classes within
top-level classes places the code closer to where it is used.

Static Nested Classes
• A static nested class is associated with its outer class similar to class
methods and variables.
• A static nested class cannot refer directly to instance variables or
methods defined in its enclosing class.
• It can use them only through an object reference.
• Static nested classes are accessed using the enclosing class name:
OuterClass.StaticNestedClass
• For example, to create an object for the static nested class, use this
syntax:
OuterClass.StaticNestedClass nestedObject =
new OuterClass.StaticNestedClass();

Inner Classes
• An inner class is associated with an instance of its enclosing class
and has direct access to that object's methods and fields.
• Because an inner class is associated with an instance, it cannot
define any static members itself.
• Objects that are instances of an inner class exist within an instance
of the outer class.
• Consider the following classes:
class OuterClass {
...
class InnerClass { ... }
}

• An instance of InnerClass can exist only within an instance of
OuterClass and has direct access to the methods and fields of its
enclosing instance.
• To instantiate an inner class, we must first instantiate the outer class.
Then, create the inner object within the outer object.
• Syntax:
OuterClass.InnerClass innerObject =
outerObject.new InnerClass();
• Additionally, there are two special kinds of inner classes:
– local classes and
– anonymous classes (also called anonymous inner classes).

Local Classes
• Local classes are classes that are defined in a block, which is a
group of zero or more statements between balanced braces.
• For example, we can define a local class in a method body, a for
loop, or an if clause.
• A local class has access to the members of its enclosing class.
• A local class has access to local variables. However, a local class
can only access local variables that are declared final.

Anonymous Classes
• Anonymous classes enable us to declare and instantiate a class
at the same time.
• They are like local classes except that they do not have a
name.
• The anonymous class expression consists of the following:
1. The new operator
2. The name of an interface to implement or a class to extend.
3. Parentheses that contain the arguments to a constructor, just like a
normal class instance creation expression.
4. A body, which is a class declaration body. More specifically, in
the body, method declarations are allowed but statements are not.

 Anonymous classes have the same access to local variables of the enclosing
scope as local classes:
• An anonymous class has access to the members of its enclosing class.
• An anonymous class cannot access local variables in its enclosing scope that are not
declared as final.
 Anonymous classes also have the same restrictions as local classes with
respect to their members:
• We cannot declare static initializers or member interfaces in an anonymous class.
• An anonymous class can have static members provided that they are constant
variables.
 Note that we can declare the following in anonymous classes:
• Fields
• Extra methods (even if they do not implement any methods of the supertype)
• Local classes
• we cannot declare constructors in an anonymous class.

Note:
When we compile a nested class, two different class files will
be created with names
Outerclass.class
Outerclass$Nestedclass.class

Classes and Nested Classes in Java

Recommended

More Related Content

What's hot (20)

Viewers also liked (17)

Similar to Classes and Nested Classes in Java (20)

More from Ravi_Kant_Sahu (12)

Recently uploaded (20)

Classes and Nested Classes in Java