In Java, a class can be defined inside another class or inside a method, and such a class is called an inner class. The inner class is still a separate class, and after compilation The inner class is compiled into a separate. class file, but preceded by the class name and the $ symbol of the outer class. An inner class can indirectly resolve multiple inheritance problems by inheriting a class using an inner class, which inherits a class and implements multiple inheritance.
Inner classes are mainly divided into members inner classes, method inner classes, static inner classes, anonymous inner classes.
1. member Inner class
The member inner class is, by definition, a member property of an external class, except that the property is not a string,int type, but a class type. The class's member inner class can access the properties and methods of the class, because he is also a member of the class.
Member Internal classes use:
Package com.dream;
public class MyTest {
public static void Main (string[] args) {
Mother Mother=new Mother (12, "Xiao Ming");
One of the methods of the instance inner class
Mother.baby temp=mother.new Baby ();
Temp.say ();
Instantiating method two, accessing the inner class by invoking the member function of the class
Mother.say ();
}
}
Class mother{
private int age;
public String name;
Public mother (int age, String name) {
This.age = age;
THIS.name = name;
}
Defining inner classes (member inner classes)
Class baby{
public void Say ()
{
System.out.println ("I have" +age+ "old", called "+name");
}
}
Instantiating in a class
public void Say ()
{
Baby Temp=new Baby ();
Temp.say ();
}
}
Copy Code
The member inner class is a member of the class, and the members of the class depend on the class object, so the inner class is also dependent on the object, and the class needs to be instantiated for use, so an external class object is used to instantiate the inner class.
2. Method Inner Class
As the name implies, the inner class defines the class within the method, which should be noted:
1. The inner class of the method can only be instantiated in the method that defines the inner class, and it cannot be instantiated outside this method
2. Method inner class object cannot use the non-final property of the method in which the inner class resides
public class MyTest {
public void Say (final String name)
{//Method inner class
Class Baby
{
public void Say ()
{
Final attribute required
System.out.println ("name" +name);
}
}
Instantiated inside the method
Baby Temp=new Baby ();
Temp.say ();
}
public static void Main (string[] args) {
MyTest test=new MyTest ();
Test.say ("Wang Xiao-shuai");
}
}
Copy Code
The scope of the inner class of a method is limited to that method, so it is instantiated within the method. The variable defined in the method is a local variable, leaving the method, the variable loses its function, it is automatically eliminated, and the inner class does not leave its method to lose its function, it has a broader life cycle, so it needs to be copied into the inner class, and the copy will bring inconsistencies, which requires the use of Final declaration to ensure consistency.
3. Static Inner class
That is, define a static inner class in a class, static is that the inner class can be like other static members, no instance of the external class object can also access the call, static property does not belong to the instance object of the class.
public class MyTest {
public int age=1;
public static String name= "small black";
Defining static internal classes
Static Class baby{
public void Say ()
{
The Age property cannot be accessed, only static properties can be accessed
System.out.println ("Name:" +name);
}
}
public static void Main (string[] args) {
Instantiate a static inner class
Mytest.baby temp=new Mytest.baby ();
Temp.say ();
}
}
Copy Code
It is important to note that static inner classes can only access static member properties and methods in external classes, because static properties can be accessed without using external instance objects, and if the property is not a static property, you need to rely on the instance object of the outer class. So static inner classes can only access static properties of external classes
4. Anonymous inner class
Anonymous inner class is a bit like anonymous object, no name, can only be used once, anonymous inner class is divided into three kinds of cases
1. Inherited anonymous inner class: You can not define class to inherit the abstract class and implement an instance of the abstract class and run
public class MyTest {
public static void Main (string[] args) {
Quite inherit the mother class and implement the abstract method
Mother Mother=new Mother (25, "Gui Lun mg") {
public void Say ()
{
System.out.println ("Age:" +age+ "Name:" +name);
}
};
Mother.say ();
}
}
Abstract class mother{
public int age;
public String name;
Public mother (int age, String name) {
This.age = age;
THIS.name = name;
}
public abstract void Say ();
}
Copy Code
2. Interface anonymous inner class: Can not define class to implement the interface and implement the call of the interface
public class MyTest {
public static void Main (string[] args) {
Equivalent to implementing an interface
Baby Temp=new Baby () {
@Override
public void Say () {
System.out.println ("Name:" +name);
}
};
Temp.say ();
}
}
Interface baby{
String name= "Small black";//interface-defined properties are constants, decorated as public final static String name
public void say ();
}
Copy Code
3. Parametric anonymous inner class: Only the final property can be accessed
public class MyTest {
public void Say (Baby temp)
{
Temp.say ();
}
public static void Main (string[] args) {
MyTest test=new MyTest ();
final int age=10;
Parameter anonymous inner class
Test.say (New Baby () {
@Override
public void Say () {
To access the properties of the final definition
System.out.println ("Age:" +age);
}
});
}
}
Interface baby{
String name= "Small black";//interface-defined properties are constants, decorated as public final static String name
public void say ();
}
Copy Code
Explains why you use the final property
It is mainly the inconsistency between the life cycle of the local variable and the object of the local inner class.
Internal class inside the use of the external class local variables, is actually the inner class object in use it, the internal class object life cycle can call it, while the inner class trying to access local variables in the external method, the local variables of the external method is probably no longer exist, it is necessary to continue their lives, copied into the inner class, Copies, in turn, create inconsistencies that require the use of final statements to ensure consistency. Replication guarantees a life-cycle continuation, and final guarantees a consistent reference.
Java Internal classes
Start building with 50+ products and up to 12 months usage for Elastic Compute Service
1 on 1 presale consultation
24/7 Technical Support 6 Free Tickets per Quarter Faster Response
Alibaba Cloud offers highly flexible support services tailored to meet your exact needs.
A comprehensive suite of global cloud computing services to power your business
Payment Methods We Support
