18 Day Regular Inner Class 1
18 Day Regular Inner Class 1
class.
EX:
class Outer {
class Inner {
----
----
Ex:
[Outer.java]
} //method end
} // inner class End
public static void main(String args[]){
Outer o=new Outer();
System.out.println(o.x); //10
/*
Outer.Inner i=new Outer().new Inner();
i.display();
*/
new Outer().new Inner().display();
} //main end
} //outer class end
-- >If we want to access the members of inner class then we have to create object for the
inner class as well as outer class object also, for this, we have to use the following syntax.
Ex:
--> By default, all outer class members are available to inner class, so we can access outer class
Members inside the inner class, but, Inner class members are not available to outer classes, we are
Note:
Inner class can use each and every thing of the outer class (Including Private members)
Ex:
class Outer {
private int x=10; //instance variable
//instance method
public void makeInner() {
System.out.println(x);
Inner i=new Inner(); // make an inner instance
i.seeOuter();
} //method end
class Inner{
/*
Outer.Inner i=o.new Inner();
i.seeOuter();
*/
} // main end
} //outer class end
Regular Inner classes (Non-static nested classes) have access to other members of the outer class/
enclosing class/container class, even if they are declared private.
--> By using outer class reference variable we are able to access only outer class members, we are
--> By using Inner class reference variable we are Able to access only inner class members we are
Note:
But From JDK 17 We Can do the static declaration in the Regular Inner classes also.
EX:
[A.java]
class A {
void m1() {
System.out.println("m1-A");
}
class B {
static int i=10; //Error, But From JDK 17 it is also okk
static final int j=20; //Okk
void m2() {
System.out.println("m2-B");
System.out.println(j);
}
void m3() {
System.out.println("m3-B");
}
} //Inner class End
} //Outer class End
[Tester.java]
class Tester{
public static void main(String[] args) {
A a=new A(); //Outer class object creation
a.m1(); //Ok
//a.m2(); // Error /CTE
A.B ab=new A().new B();
ab.m2(); //ok
ab.m3(); //ok
In Member inner classes / Regular Inner class, we can extend one inner class to another inner class but
both the inner classes must be provided with in the same outer class.
EX:
class A {
class B {
void m1() {
System.out.println("m1-B");
}
void m2()
{
System.out.println("m2-B");
}
} // Inner class end
class C extends B //Ok bcz B and C are from the same outer class
{
void m3() {
System.out.println("m3-C");
}
void m4(){
System.out.println("m4-C");
}
} //Inner class End
} //Outer class End
class Tester {
public static void main(String[] args) {
A.B ab=new A().new C(); //Upcasting
ab.m1();
ab.m2();
//ab.m3(); //--> Error Method check with reference & call with object
A.C ac=new A().new C();
ac.m1();
ac.m2();
ac.m3();
ac.m4();
}
}
We can not inherit one inner class to another inner class which are available in two different
outer classes.
EX:
class A {
class B {
---
} //inner class end
} //Outer class end
class C {
class D extends A.B //CTE because B is from diff outer class
{
---
}
}
Status: Invalid.
class A{
void m1(){
System.out.println("I am A.m1");
}
} //External class end
class B{
}
}
public class Tester{
public static void main(String[] args){
B.C bc=new B().new C();
bc.m1();
bc.m2();
}
}
Status: Valid
class A
class B extends A
---
Ans:
Yes, it is possible to provide an interface inside a class, but, the respective implementation
EX:
class A {
interface I {
void m1();
void m2();
void m3();
} //Inner interface end
class B implements I {
public void m1() {
System.out.println("m1-B");
}
Yes
EX:
class A {
abstract class B {
void m1() {
System.out.println("m1-B");
}
abstract void m2();
abstract void m3();
} //inner class end
class C extends B {
void m2() {
System.out.println("m2-C");
}
void m3()
{
System.out.println("m3-C");
}
} //Inner class end
} //Outer class End
class Tester {
public static void main(String[] args) {
A.B ab=new A().new C(); // Upcasting
ab.m1();
ab.m2();
ab.m3();
}
}
Class inside Abstract class:
EX:
abstract class A {
class B {
void m1(){
System.out.println("m1-B");
void m2(){
System.out.println("m2-B");
System.out.println("m3-B");
class C extends A{
/*
class B
----
----
*/
class Tester{
ab.m1();
ab.m2();
ab.m3();
EX:
abstract class A
abstract class B
void m1()
System.out.println("m1-B");
class C extends B
@Override
void m2()
System.out.println("m2-C");
@Override
void m3()
System.out.println("m3-C");
class D extends A
/*
Now B and C has become the part of D class Because we are inheriting A, and B & C
are the Part of A that is why they have become the part of D
} // D class End
class Tester
ab.m1();
ab.m2();
ab.m3();
Ex:
abstract class A
interface I
void m1();
void m2();
void m3();
class B implements I
@Override
System.out.println("m1-B");
@Override
@Override
System.out.println("m3-B");
class C extends A
class Tester
ai.m1();
ai.m2();
ai.m3();
class Outer
class Inner
int x=40;
void show()
System.out.println(x); //40
System.out.println(Outer.this.x); //10
//or
i.show();
//Not allowed