Internal Classes in Java Language

I. Overview of Internal Classes

Internal classes are defined as internal classes of another class, then this class is called internal classes, and the other class is called external classes. For example, class A is defined in class B, class A is called internal class, and class B is called external class. According to the location of the definition, we classify internal classes into member internal classes and local internal classes. All internal classes have direct access to members of external classes (including member variables, member methods) and private members. To access members of all internal classes (including member variables, member methods), external classes must create objects.

II. Internal Classes of Members

1. The concept of inner class of members

Classes defined at member locations are called member internal classes.

2. Code format of member inner classes

class A{
    int b=10
    class B{
    }
    public static void main(String[] args) {
	}
}

So how do I access members of internal classes directly in test classes?

Format: External class name. Internal class name object name = External class object. Internal class object;

3. Common modifiers of member inner classes and their applications

The modifiers of the inner class of a member are:

(1) private: To ensure data security
(2) static: for easy access to data

• Notes: (1) External class data accessed by static internal classes must be static modified.
  (2) Membership methods can be static or non-static, and the access methods of static modified inner classes of members are as follows:

  Format: External class name. Internal class name object name = new external class name. Internal class name ();
  

For example:

ublic class Outer {
    int num = 10;
    private int a = 100;
    //Define member inner classes
    class Inner {
        int b = 109;
        public void innerShow() {
            System.out.println("Inner class show Method");
        }
        //Internal classes have direct access to members of external classes, including private ones.
        public void innerTest(){
            System.out.println(num);
            System.out.println(a);
            outerShow();
            outerTest();
        }
    }
    public void outerShow() {
        System.out.println("This is an external class show Method");
    }
    private void outerTest() {
        System.out.println("This is an external class show Method");
    }
    //External classes, which want to access members of internal classes, have to create objects of internal classes
    public void method(){
        //Create objects for internal classes
        Inner inner = new Inner();
        System.out.println(inner.b);
        inner.innerShow();
    }
}

public class MyTest {
    public static void main(String[] args) {
        Outer outer = new Outer();
        System.out.println(outer.num);
        outer.outerShow();
        System.out.println("--------------------------------");
        //Use the attributes and methods of member inner classes
        //Syntax for creating member inner classes
        Outer.Inner inner=new Outer().new Inner();
        System.out.println(inner.b);
        inner.innerShow();
        System.out.println("---------------");
        outer.method();
    }
}

The results are as follows.

3. Local Internal Classes

1. The Concept of Local Internal Classes

A method that defines an internal class to an external class is called a local internal class.

2. Code format of local internal classes

	class A{
    	int b=10
    public static void main(String[] args) {
    	class B{
    	}
	}
}

3. Problem of Accessing Local Variables by Local Internal Classes

Local internal classes have direct access to members of external classes (including member variables, member methods) and private members. When member methods access internal classes, they need to create internal class objects and invoke internal class methods to use local internal class functions. Local internal class access to local variables must be final ized, because local variables will disappear as the method is called, and local objects do not immediately disappear from heap memory, but also use that variable, so in order to allow data to continue to be used, we must use fianl modification, so that a constant value will be stored in heap memory.

For example:

//Create external and local internal classes
public class Outer {
    int num=10;
    private int a=100;
    public void waiShow(){
       final int b=20;
        //Define local inner classes
        class Inner{
            int c=1;
            public void neiShow(){
                System.out.println("The local variables are:"+b);
                System.out.println("Internal member variables are:"+c);
                System.out.println("The external member variable is"+num);
                System.out.println("External private member variables are:"+a);  //Internal classes have direct access to members of external classes, including private members.
            }
        }
        Inner inner = new Inner();
        inner.neiShow();
    }
    public void waiTest(){
       waiShow();
    }
}

//Create test classes to test the properties and functions of classes
public class MyTest {
    public static void main(String[] args) {
        //Local internal classes, external objects cannot be created directly
        Outer outer = new Outer();
        outer.waiTest();
    }
}

The results are as follows: