[Java Basics] A brief introduction to internal classes and their characteristics

About inner classes

Inner classes are a type of nested classes, and nested classes have Four types: [Source]

1. static nested class Static nested class, close to ordinary classes, has no reference to the external class; it can only access the static ** of the external class, and can define non- Static method, if the inner class has static **, the class must be static;

2. inner class inner class (non-static), real inner class;

3. local class local class (defined inside the method), real internal class;

4. anonymous class anonymous class, real internal class, more suitable for use only once and the implemented method is not Multiple classes;

The real inner class can directly access the instance variables and methods of the outer encapsulated class [Source]

Features: [Source]

1. An inner class and its outer class can access each other’s properties and methods (even if private) (JAVA8)

1). Before 8, anonymous inner classes used The life cycle of local variables is inconsistent with the life cycle of internal class objects

2) The scope of member variables of internal classes stays within the method. When the method execution ends, the local variables disappear, but the scope of the member variables that refer to them disappears. It may exist internally, but when the internal class is called again, it will access a non-existent variable!

3), so final must be used before jdk8. After decompilation, it can be seen that the inner class will actually generate a class with a constructor, and the referenced variables are passed in as parameters, including the external class instance (this is why the internal class will hold the external class by default The reference of the object can easily cause memory leaks), and then assigns the value to its own variable. That is to say, if the value of the external variable is changed in the inner class, actually changes only the variable value of the inner class itself, It is not the value of an external variable, just like a variable passed by a method. Changing its value in the method will cause the external variable to change. The variables in the method are all local. So in order to prevent this inconsistency from occurring, it must be final. [Source]

4) Java8 introduces the concept of effectively final. When an inner class accesses an outer class variable, as long as the inner class does not reassign the outer variable, then the outer class variable is a de facto final variable. , Java will implicitly declare external variables as final. [Source]

5) Why is it final? The reasons are briefly explained above. For the sake of length, ahem ~ excellence, let’s elaborate again: when the variable is final, by "copying" the final local variable As a data member of a local inner class, when a local inner class accesses a local variable, what is actually accessed is a "copy" of the local variable. When the real local variable in the run stack dies, the inner class object can still access the local variable ( (It seems that the life span of local variables has been extended). So far, it has not much to do with final. O(∩_∩)O haha~ In the name of "final", we will eventually return to final. The variable is final: [Source]

1. Reference type: its reference value remains unchanged (always points to the same object), and the copy is the same as the original reference variable [Source]

2. Basic data type : When a variable is final, because its value does not change, its copy is the same as the original quantity, and the semantic effect is the same

[Source]

Internal class: [Source]

Reflects the logical affiliation. For other classes, the internal class can be controlled to be invisible to the outside world

The scope of the member variables of the external class is the entire external class (including internal classes) , but the external class cannot access the private members of the inner class)

After compilation, the inner class is compiled into a separate class, in the form of outClass$innerClass

static:

Static initialization Container: Static block: A static block that exists outside a class method and is only executed once when the class is loaded. It is commonly used to initialize static class attributes.

1. Static methods cannot be overridden by non-static methods; 2. Constructors are not allowed to be declared static

final: final state characteristics

1. Cannot be covered by foundation or quilt Variables overridden and marked by classes are constants

2. Assign a value at the time of declaration. If not, there is only one opportunity for assignment and the value can only be assigned explicitly in the constructor.

Exception:

Under normal circumstances, do not use statements such as return or throw in the finally block that cause the method to terminate. Otherwise, the return and throw statements in the try block and catch block will become invalid. The return statement in the finally block will Cause the exception to be lost. 【Source】【Source】

In try...catch, if there are multiple catches, the exceptions of the parent class should be placed under the exceptions of the subclass, otherwise the compilation will fail. I’m not too lazy to test this. Colleagues passing by can give me some opinions ^_^

Why are internal classes and exceptions often written together? It seems that I need to summarize the exceptions and fall into a nine-link chain. But don’t worry about the next step. This article is already too much.

Related articles:

Detailed explanation of Java basic internal class examples

Java basic internal class Detailed explanation of the example code

Related videos:

Internal class classification and direct use of member internal classes-JAVA primary introductory video tutorial

The above is the detailed content of [Java Basics] A brief introduction to internal classes and their characteristics. For more information, please follow other related articles on the PHP Chinese website!