Dt : 22/6/2022

Execution flow of above program:

ClassFiles:

SubClass1.class

SubClass1$SubClass2.class

DemoInnerClass2.class(MainClass)

Note:

=>In Instance member InnerClass the InnerClass object will hold the reference of

OuterClass object,in this process the methods of InnerClass object can access the

members of OuterClass object directly.

--------------------------------------------------------------------

*imp

1
2.Local member InnerClasses:

=>The NonStatic member InnerClasses which are declared inside the methods of

OuterClass are known as Local member InnerClasses.

Rules:

=>NonStatic member InnerClass declared inside the instance method of OuterClass

will have behaviour like 'Instance member InnerClass'.

=>The NonStatic member InnerClass declared inside the static method of

OuterClass will have behaviour like 'Static member InnerClass'.

=>Local InnerClass objects are created inside the same methods where

Local InnerClasses are declared.

Ex:

2
SubClass1.java

package p2;
public class SubClass1 {
public int a=10;
public static int b=20;
public void m1() {
class SubClass2{
public void m2() {
System.out.println("===Instance m2()====");
System.out.println("The value a:"+a);
System.out.println("The value b:"+b);
}
public static void m22() {
System.out.println("===Static m22()====");
//System.out.println("The value a:"+a);
System.out.println("The value b:"+b);
}
}//InnerClass
SubClass2 ob2 = new SubClass2();//InnerClass Object
ob2.m2();
SubClass2.m22();
}//OuterClass Instance method
public static void m11() {
class SubClass22{
public void m3() {
System.out.println("===Instance m3()====");
//System.out.println("The value a:"+a);
System.out.println("The value b:"+b);
}
public static void m33() {
System.out.println("===Static m33()====");
//System.out.println("The value a:"+a);
System.out.println("The value b:"+b);
}
}//InnerClass
SubClass22 ob22 = new SubClass22();//InnerClass object
ob22.m3();
SubClass22.m33();
}//OuterClass Static method
}//OuterClass

DemoInnerClass3.java(MainClass)

3
package p1;
import p2.*;
public class DemoInnerClass3 {
public static void main(String[] args) {
SubClass1 ob1 = new SubClass1();//OuterClass object
ob1.m1();//OuterClass Instance method Call
SubClass1.m11();//OuterClass Static method Call
}
}

o/p:

===Instance m2()====

The value a:10

The value b:20

===Static m22()====

The value b:20

===Instance m3()====

The value b:20

===Static m33()====

The value b:20

-----------------------------------------------------------------

ClassFiles:

SubClass1.class

SubClass1$1SubClass2.class

SubClass1$1SubClass22.class

DemoInnerClass3.class(MainClass)

====================================================================

4
Summary:

=>Local InnerClasses inside Instance methods are 'Instance member InnerClasses'

=>Local InnerClasses inside Static methods are 'Static member InnerClasses'.

=>In Static member InnerClasses,InnerClasses will get the memory within the

OuterClass.

=>In Instance member InnerClasses,InnerClasses objects will hold the reference

of OuterClass objects.

========================================================================

Dt : 23/6/2022

*imp

define Generalization process?

=>The process in which one object is created holding all the member from the

PClass and only Overriding members from the CClass is known as Generalization

process.

=>we use the following syntax to perform Generalization process:

PClass ob = new CClass();

Diagram:

5
Ex:

PClass.java

package test;
public class PClass {
public PClass(int z) {
System.out.println("===PClass(z)===");
System.out.println("The value z:"+z);
}
public void m1(int x) {
System.out.println("====PClass m1(x)===");
System.out.println("The value x:"+x);
}
public void m2(int y) {
System.out.println("====PClass m2(y)===");
System.out.println("The value y:"+y);
}
}

CClass.java

package test;
public class CClass extends PClass{
public CClass(int k) {
super(k);
System.out.println("====CClas(k)===");
System.out.println("The value k:"+k);
}

6
 public void m1(int x) {
System.out.println("====CClass m1(x)===");
System.out.println("The value x:"+x);
}
public void m3(int z) {
System.out.println("====CClass m3(z)===");
System.out.println("The value z:"+z);
}
}

DemoGeneralization1.java(MainClass)

package maccess;
import test.*;
public class DemoGeneralization1 {
public static void main(String[] args) {
PClass ob = new CClass(111);//Generalization_Con_Call
ob.m1(123);
ob.m2(234);
//ob.m3(235);//Error
}
}

o/p:

===PClass(z)===

The value z:111

====CClas(k)===

The value k:111

====CClass m1(x)===

The value x:123

====PClass m2(y)===

The value y:234

==================================================================

7
Note:

=>We can also perform Generalization process on Interfaces using the following

Syntax:

ITest ob = new IClass();

Diagram:

Ex:

ITest.java

package test;
public interface ITest {
public abstract void m1(int x);
public default void m2(int y) {
System.out.println("===default m2(y)====");
System.out.println("The value y:"+y);
}
}

IClass.java

package test;
public class IClass implements ITest{
public IClass(int k) {
System.out.println("====IClass(k)====");
System.out.println("The value k:"+k);

8
 }
public void m1(int x) {
System.out.println("===implemented m1(x)===");
System.out.println("The value x:"+x);
}
public void m3(int z) {
System.out.println("===NonImplemented m3(z)====");
System.out.println("The value z:"+z);
}
}

DemoGeneralization2.java(MainClass)

package maccess;
import test.*;
public class DemoGeneralization2 {
public static void main(String[] args) {
ITest ob = new IClass(111);//Generalization
ob.m1(12);
ob.m2(23);
//ob.m3(56);//Error
}
}

o/p:

====IClass(k)====

The value k:111

===implemented m1(x)===

The value x:12

===default m2(y)====

The value y:23

========================================================================
=

9
Note:

=>Generalization process is also know as Widening process or Implicit TypeCasting

process or UpCasting process.

========================================================================

faq:

define Specialization process?

=>The process in which we construct CClass by taking one feature from the

PClass is known as Specialization process.

=>we use the following syntax to perform Specialization process:

CClass ob = (CClass)new PClass();

Rule:

=>In Specialization process the PClass must be Built-in Class or Pre-defined

class,if not raises 'java.lang.ClassCastException'.

Note:

=>Specialization process is also known as Narrowing process or Explicit

TypeCasting process or DownCasting process.

=>Specialization process cannot be performed using Interfaces.

Ex for Specialization:

Cloning process

De-Serialization process

10
========================================================================
===

*imp

(b)Anonymous InnerClasses:

=>The InnerClasses which are declared without name are known as Anonymous

InnerClasses.

=>These Anonymous InnerClasses are categorized into two types:

(i)Anonymous InnerClass as Class extention

(ii)Anonymous InnerClass as Implementation class

(i)Anonymous InnerClass as Class extention:

=>The process of declaring CClass without name is known as Anonymous InnerClass

as Class extention.

syntax:

class PClass

//PClass_body

PClass ob = new PClass()

//CClass_body

11
};

Ex:

PClass.java

package test;
public class PClass {
public void m1(int x) {
System.out.println("====PClass m1(x)===");
System.out.println("The value x:"+x);
}
public void m2(int y) {
System.out.println("====PClass m2(y)===");
System.out.println("The value y:"+y);
}
}

DemoAnonymous1.java(MainClass)

package maccess;
import test.*;
public class DemoAnonymous1 {
public static void main(String[] args) {
//Anonymous InnerClass as Class_extention
PClass ob = new PClass()
{
public void m1(int x) {
System.out.println("====CClass m1(x)===");
System.out.println("The value x:"+x);
}
public void m3(int z) {
System.out.println("====CClass m3(z)===");
System.out.println("The value z:"+z);
}
};
ob.m1(123);
ob.m2(234);
//ob.m3(235);//Error
}
}

12
o/p:

====CClass m1(x)===

The value x:123

====PClass m2(y)===

The value y:234

Note:

=>'Anonymous InnerClass as Class extention' is modified model of Generalization

process using Classes.

======================================================================

(ii)Anonymous InnerClass as Implementation class:

=>The process of declaring implementation class without name is known as

'Anonymous InnerClass as implementation class'.

syntax:

interface ITest

//Interface_body

ITest ob = new ITest()

//IClass_body

13
};

Ex:

ITest.java

package test;
public interface ITest {
public abstract void m1(int x);
public default void m2(int y) {
System.out.println("===default m2(y)====");
System.out.println("The value y:"+y);
}
}

DemoAnonymous2.java(MainClass)

package maccess;
import test.*;
public class DemoAnonymous2 {
public static void main(String[] args) {
//Anonymous InnerClass as implementation class
ITest ob = new ITest()
{
public void m1(int x) {
System.out.println("===implemented
m1(x)===");
System.out.println("The value x:"+x);
}
public void m3(int z) {
System.out.println("===NonImplemented
m3(z)====");
System.out.println("The value z:"+z);
}
};
ob.m1(12);
ob.m2(23);
//ob.m3(56);//Error
}
}

14
o/p:

===implemented m1(x)===

The value x:12

===default m2(y)====

The value y:23

Note:

=>Anonymous InnerClass as implementation class is the modified model of

Generalization process using Interfaces.

=================================================================

15