[README]
1. This paper summarizes four internal classes of Java, including
- Member inner class: a non static class defined inside an outer class; Internal classes of members cannot exist independently, such as composition in UML;
- Static internal class: a static class defined inside an external class; Static classes are closely related to external classes, but they can exist independently, such as aggregation in UML;
- Local inner class: an inner class defined inside a method; Its scope is within the method;
- Anonymous inner class: as the name suggests, an inner class without a name is usually used to implement an interface without a custom constructor;;
2. This paper gives the relevant test cases;
3. Functions of internal classes
- 1. The internal class has its own implementation, which is helpful for the external class to realize multi inheritance; Multiple internal classes are defined in an external class, and each internal class inherits a parent class to realize multiple inheritance in disguise;
- 2. Improve code cohesion;
[1] Introduction to internal classes
[1.1] member internal class
1) Member inner class: a non static class defined inside an outer class; Internal classes of members cannot exist independently;
2) Code structure
/** * @Description Member inner class * @author xiao tang * @version 1.0.0 * @createTime 2021 November 21 */ public class Topic78 { private String name; public Topic78(String name) { this.name = name; } // Member inner class public class MemberInnerClass { private int age; public MemberInnerClass(int age) { this.age = age; } // Inside the external class definition, use the external class. this pointer to point to the reference to the external class object public String hello() { return "hello " + Topic78.this.name; } } }
3) Test case
public class MemberInnerClassTest { public static void main(String[] args) { Topic78 topic78 = new Topic78("lisi"); // Create member inner class // In the external class definition, use the external class object. new pointer to point to the reference to the external class object Topic78.MemberInnerClass memberInnerClass = topic78.new MemberInnerClass(18); System.out.println(memberInnerClass.hello()); // hello lisi } }
Note: the inner class of the member uses two pointers: the outer class object. new and the outer class. this;
- External class object. new pointer: refers to a reference to an external class object; (used when creating internal class objects)
- External class. this pointer: refers to a reference to an external class object; (used when the inner class uses the properties of the outer class object)
[1.2] static internal class
1) Definition: static internal class, static class defined inside external class; Static classes are closely related to external classes, but they can exist independently, such as aggregation in UML;
2) Code structure
/** * @Description Static inner class * @author xiao tang * @version 1.0.0 * @createTime 2021 November 21 */ public class Topic77 { /** * @description Static inner class * @author xiao tang * @date 2021/11/21 */ public static class StaticInnerClass { String name; public StaticInnerClass(String name) { this.name = name; } public void sayHello() { System.out.println("hello " + name); } } }
3) Test case:;
/** * @Description TODO * @author xiao tang * @version 1.0.0 * @createTime 2021 November 21 */ public class StaticInnerClassTest { public static void main(String[] args) { Topic77.StaticInnerClass staticInnerClass = new Topic77.StaticInnerClass("zhangsan"); staticInnerClass.sayHello(); // hello zhangsan } }
[1.3] local internal class
1) Definition: local internal class, internal class defined inside the method;
- Its scope: the current method block and all members accessing the external class; But it cannot be defined and used outside the current method;
2) Code structure
/** * @Description Local inner class * @author xiao tang * @version 1.0.0 * @createTime 2021 November 21 */ public class LocalInnerClassTest { private String name; public LocalInnerClassTest(String name) { this.name = name; } public void sayHello() { // Define a local class inside a method // Its scope: the current method block and all members accessing the external class; (it cannot be defined and used outside the current method) class LocalInnerClass { public String hello() { return "hello " + name; } public String nice2MeetYou() { return "nice to meet you"; } } LocalInnerClass localInnerClass = new LocalInnerClass(); System.out.println(localInnerClass.hello()); System.out.println(localInnerClass.nice2MeetYou()); } public static void main(String[] args) { new LocalInnerClassTest("lisi").sayHello(); } }
3) Test case:
ditto;
hello lisi
nice to meet you
[1.4] anonymous inner class
1) Definition: anonymous internal class. As the name suggests, an internal class without a name is usually used to implement an interface without a user-defined constructor;
2) Code structure: implement Runnable interface by concurrent programming
/** * @Description Anonymous Inner Class * @author xiao tang * @version 1.0.0 * @createTime 2021 November 21 */ public class AnonymousInnerClassTest { public static void main(String[] args) { // The Runnable interface is implemented through anonymous internal classes to simplify the code Runnable runnable = new Runnable() { @Override public void run() { System.out.println("hello world"); } }; runnable.run(); } }