Scribd
Upload
37 views

Nestedclass 150428011452 Conversion Gate01

This document discusses nested classes in Java. It defines nested classes as member classes of an enclosing class and distinguishes between static and non-static (inner) nested classes. Static nested classes cannot access members of the enclosing class, while inner classes can access both static and non-static members of the enclosing class. Nested classes increase encapsulation and lead to more readable code by grouping related classes. The document provides examples of using nested, local, anonymous, and shadowed classes in Java code.

Uploaded by

Nitish Sarin
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPTX, PDF, TXT or read online on Scribd
37 views

Nestedclass 150428011452 Conversion Gate01

This document discusses nested classes in Java. It defines nested classes as member classes of an enclosing class and distinguishes between static and non-static (inner) nested classes. Static nested classes cannot access members of the enclosing class, while inner classes can access both static and non-static members of the enclosing class. Nested classes increase encapsulation and lead to more readable code by grouping related classes. The document provides examples of using nested, local, anonymous, and shadowed classes in Java code.

Uploaded by

Nitish Sarin
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPTX, PDF, TXT or read online on Scribd
You are on page 1/ 25

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

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();
Output
fl.methodInFirstLevel(23);
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);

You might also like