Nested class

Example
class OuterClass { ... class NestedClass { ... } }
• Nested classes are divided into two categories:
static and non-static.
• Nested classes that are declared static are
called static nested classes.
• Non-static nested classes are called inner
classes.

class OuterClass { ...
static class StaticNestedClass { ... }
class InnerClass { ... }
}
A nested class is a member of its enclosing class.
Non-static nested classes (inner classes) have access to other
members of the enclosing class, even if they are declared
private.
Static nested classes do not have access to other members of
the enclosing class.
As a member of the OuterClass, a nested class can be
declared private, public, protected, or package private.

Why Use Nested Classes?
• Compelling reasons for using nested classes include the following:
• It is a way of logically grouping classes that are only used in one
place: 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. Nesting such
"helper classes" makes their package more streamlined.
• It increases 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.
• It can lead to more readable and maintainable code: Nesting small
classes within top-level classes places the code closer to where it is
used.

Static Nested Classes
• As with class methods and variables, a static nested class is
associated with its outer class.
• Like static class methods, 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
• As with instance methods and variables, an
inner class is associated with an instance of its
enclosing class and has direct access to that
object's methods and fields.
• Also, because an inner class is associated with
an instance, it cannot define any static
members itself.

Example
• 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, you must first instantiate the outer class.
Then, create the inner object within the outer object with this syntax:
OuterClass.InnerClass innerObject = outerObject.new InnerClass();
• There are two special kinds of inner classes: local classes and anonymous
classes.

Local Classes
• Declaring Local Classes
public class LocalClassExample {
static String regularExpression = "[^0-9]";
public static void validatePhoneNumber(
String phoneNumber1, String phoneNumber2) {
final int numberLength = 10;
class PhoneNumber {
String formattedPhoneNumber = null;
PhoneNumber(String phoneNumber){
String currentNumber = phoneNumber.replaceAll(
regularExpression, "");
if (currentNumber.length() == numberLength)
formattedPhoneNumber = currentNumber;
else
formattedPhoneNumber = null;
}

public String getNumber() {
return formattedPhoneNumber;
}
PhoneNumber myNumber1 = new PhoneNumber(phoneNumber1);
PhoneNumber myNumber2 = new PhoneNumber(phoneNumber2);
if (myNumber1.getNumber() == null)
System.out.println("First number is invalid");
else
System.out.println("First number is " + myNumber1.getNumber());
if (myNumber2.getNumber() == null)
System.out.println("Second number is invalid");
else
System.out.println("Second number is " + myNumber2.getNumber());
}
public static void main(String... args) {
validatePhoneNumber("123-456-7890", "456-7890");
}
} Output:
First number is 1234567890
Second number is invalid

Anonymous Classes
• Anonymous classes enable you to make your
code more concise.
• They enable you to declare and instantiate a
class at the same time.
• They are like local classes except that they do
not have a name.
• Use them if you need to use a local class only
once.

Shadowing
• If a declaration of a type (such as a member
variable or a parameter name) in a particular
scope (such as an inner class or a method
definition) has the same name as another
declaration in the enclosing scope, then the
declaration shadows the declaration of the
enclosing scope.
• You cannot refer to a shadowed declaration by
its name alone.

public class ShadowTest {
public int x = 0;
class FirstLevel {
public int x = 1;
void methodInFirstLevel(int x) {
System.out.println("x = " + x);
System.out.println("this.x = " + this.x);
System.out.println("ShadowTest.this.x = " +
ShadowTest.this.x);
}
}
public static void main(String... args) {
ShadowTest st = new ShadowTest();
ShadowTest.FirstLevel fl = st.new FirstLevel();
fl.methodInFirstLevel(23);
}
}
Output
x = 23
this.x = 1
ShadowTest.this.x = 0

• This example defines three variables named x:
– the member variable of the class ShadowTest,
– the member variable of the inner class FirstLevel,
– and the parameter in the method methodInFirstLevel.
• The variable x defined as a parameter of the method
methodInFirstLevel shadows the variable of the inner class
FirstLevel.
• Consequently, when you use the variable x in the method
methodInFirstLevel, it refers to the method parameter.
• To refer to the member variable of the inner class FirstLevel, use the
keyword this to represent the enclosing scope:
System.out.println("this.x = " + this.x);
• Refer to member variables that enclose larger scopes by the class
name to which they belong.
• For example, the following statement accesses the member
variable of the class ShadowTest from the method
methodInFirstLevel:
System.out.println("ShadowTest.this.x = " + ShadowTest.this.x);

Nested class

Recommended

More Related Content

What's hot (20)

Similar to Nested class (20)

More from Daman Toor (15)

Recently uploaded (20)

Nested class