Accumulation of internal classes in Java

Here static, which is decorated with the static keyword, includes classes, methods, blocks, fields.

Non-static, which is not modified with static.

Static has some features:

1. Globally unique, any modification is a global impact

2. Load only once, prior to non-static

3. The usage is not dependent on the instance object.

4. The lifecycle belongs to the class level, from the beginning of the JVM loading to the end of JVM uninstallation.

Refer to: http://blog.csdn.net/zhandoushi1982/article/details/8453522/.

For the differences between static inner classes (nested classes) and non-static inner classes, refer to:

Http://www.jb51.net/article/74838.htm

(1) Internal static classes do not need to have references to external classes. But non-static inner classes need to hold references to the external class.

(2) non-static inner classes can access static and non-static members of external classes. Static classes cannot access non-static members of external classes. He can only access static members of external classes.

(3) A non-static inner class cannot be created from an external class entity, and a non-static inner class can access the data and methods of the external class, because he is inside the outer class.

/* The following program demonstrates how to create a static inner class and a non-static inner class in Java */class outerclass{private static String msg = "Geeksforgeeks"; Static inner class public static class nestedstaticclass{//Static inner class can only access static members of external classes public void Printmessage () {//try to change msg to non-static     Compiler Error SYSTEM.OUT.PRINTLN ("Message from nested static class:" + msg); }}//non-Static inside class public class innerclass{//both static and non-static methods can access public void display () in non-static inner classes () {System.out.print    ln ("Message from Non-static nested class:" + msg); }}}} class main{//How to create an instance of a static inner class and a non-static inner class public static void Main (String args[]) {//Create an instance of a static inner class OUTERCLASS.NESTEDST    Aticclass printer = new Outerclass.nestedstaticclass ();      Create a static internal class non-static method Printer.printmessage ();        In order to create a non-static inner class, we need an instance of the outer class outerclass outer = new Outerclass ();    Outerclass.innerclass inner = outer.new innerclass ();    A non-static method called Inner.display () that calls a non-static inner class;    We can also combine the steps above to create an internal class instance Outerclass.innerclass InnerObject = new Outerclass (). New Innerclass (); Also we can now invoke the internalClass method Innerobject.display (); }}

A brief introduction to the anonymous inner class is made in the Java improvement-----, but there are many other details in the inner class, so this blog is derived. In this blog you can learn about the use of anonymous internal classes, what to note about anonymous inner classes, how to initialize anonymous inner classes, and why the formal parameters used by anonymous inner classes are final.

First, use anonymous inner class inner class

Anonymous inner class because there is no name, it is created in a somewhat strange way. The creation format is as follows:

[Java]View PlainCopy

1. New parent class Constructor (parameter list) | Implement Interface ()
2. {
3. //Anonymous inner class part of the class body
4. }

Here we see the use of anonymous inner classes we have to inherit a parent class or implement an interface, and of course only inherit one parent class or implement an interface. It also does not have the class keyword, because the anonymous inner class is a reference that uses new directly to generate an object. Of course, this reference is implicit.

[Java]View PlainCopy

2. Public Abstract class Bird {
4. private String name;
8. Public String GetName () {
10. return name;
12. }
16. public void SetName (String name) {
18. this.name = name;
20. }
24. public abstract int fly ();
26. }
30. Public class Test {
34. public void Test (Bird Bird) {
36. System.out.println (Bird.getname () + "able to fly" + bird.fly () + "M");
38. }
42. public static void Main (string[] args) {
44. Test test = new test ();
46. Test.test (new Bird () {
50. Public int Fly () {
52. return 10000;
54. }
58. Public String GetName () {
60. return "Wild Goose";
62. }
64. });
66. }
68. }
70. ------------------
72. Output:
74. Geese can fly 10000 meters

In the test class, the test () method accepts a parameter of type bird, and we know that there is no way for an abstract class to be directly new, we must first have an implementation class in order to new out of its implementation class instance. Therefore, the anonymous inner class is used directly in the Mian method to create an bird instance.

Because an anonymous inner class cannot be an abstract class, it must implement its abstract parent class or all the abstract methods inside the interface.

For this anonymous inner class code can be split into the following form:

[Java]View PlainCopy

2. Public class Wildgoose extends bird{
4. Public int Fly () {
6. return 10000;
8. }
12. Public String GetName () {
14. return "Wild Goose";
16. }
18. }
22. Wildgoose wildgoose = new Wildgoose ();
24. Test.test (Wildgoose);

Here the system creates an object that inherits from the anonymous class of the bird class and transforms it into a reference to the bird type.

There is a flaw in the use of anonymous inner classes, that is, it can only be used once, when an anonymous inner class is created, it immediately creates an instance of the class, and the definition of the class disappears immediately, so the anonymous inner class cannot be reused. For the above example, if we need to use multiple internal classes within the test () method, it is recommended that you redefine the class instead of using an anonymous inner class.

Second, the matters needing attention

In the process of using anonymous inner classes, we need to pay attention to the following points:

1 . When using anonymous inner classes, we must inherit a class or implement an interface, but both cannot be combined, and can inherit only one class or implement an interface.

2 . The constructor cannot be defined in an anonymous inner class.

3 . No static member variables and static methods can exist in the anonymous inner class.

4 . The anonymous inner class is a local inner class, so all the limitations of the local inner class also take effect on the anonymous inner class.

5 . An anonymous inner class cannot be abstract, it must implement all the abstract methods of an inherited class or an implemented interface.

Iii. why the formal parameters used are final

Reference documents: http://android.blog.51cto.com/268543/384844

When we pass parameters to an anonymous inner class, the formal parameter must be final if it needs to be used in the inner class. That is , the parameter must be final when the formal parameter of the method is used inside the inner class.

Why does it have to be final?

First we know that after the internal class is successfully compiled, it produces a class file that is not the same class file as the external class, and only retains references to external classes. When an external class passes in a parameter that needs to be called by an inner class, it is called directly from the Java program's point of view:

[Java]View PlainCopy

2. Public class Outerclass {
4. public void display (final String name,string age) {
6. class innerclass{
8. void Display () {
10. SYSTEM.OUT.PRINTLN (name);
12. }
14. }
16. }
18. }

From the above code, it seems that the name parameter should be called directly by the inner class. In fact, after the Java compilation, the actual operation is as follows:

[Java]View PlainCopy

2. Public class Outerclass$innerclass {
4. Public Innerclass (String name,string age) {
6. This .  Innerclass$name = name;
8. This .  Innerclass$age = age;
10. }
16. public void display () {
18. System.out.println (This. Innerclass$name + "----" + this .  Innerclass$age);
20. }
22. }

Therefore, from the above code, the inner class is not directly invoke the parameters passed by the method, but instead uses its own constructor to back up the parameters passed in, its own internal method calls the actual time its own property rather than the external method passed in the parameters.

Until there's no explanation why it's final? The properties in the inner class and the parameters of the external method both look the same thing from the outside, but they are not, so they can be arbitrarily changed, that is, in the inner class my change to the property does not affect the external parameter, but this is not feasible from the programmer's point of view, After all, from the point of view of the program, these two are the same, if the inner class is changed, and the external method's parameters are not changed this is difficult to understand and unacceptable, so in order to maintain the consistency of the parameter, it is necessary to use final to avoid the formal parameter unchanged.

The simple understanding is that a copy reference, in order to avoid the reference value changes, such as by the external class method modification, and so on, resulting in the internal class resulting in inconsistent values, so use final to make the reference immutable.

Therefore, if an anonymous inner class is defined and you want it to use an externally defined parameter, the compiler will require that the parameter reference be final.

Iv. Anonymous Internal class initialization

We generally use constructors to do the initialization of an instance, but the anonymous inner class is not a constructor! So how do you initialize an anonymous inner class? Use Construction code blocks! The effect of creating a constructor for an anonymous inner class can be achieved by constructing a block of code.

[Java]View PlainCopy

2. Public class Outclass {
4. Public innerclass Getinnerclass (final int. Age,final String name) {
6. return New Innerclass () {
8. int Age_;
10. String name_;
12. //Construct code block to complete initialization work
14. {
16. if (0 < Age && Age < $ ) {
18. Age_ = age;
20. name_ = name;
22. }
24. }
26. Public String GetName () {
28. return name_;
30. }
34. public int getage () {
36. return age_;
38. }
40. };
42. }
46. public static void Main (string[] args) {
48. Outclass out = new Outclass ();
52. Innerclass inner_1 = Out.getinnerclass (201, "Chenssy");
54. System.out.println (Inner_1.getname ());
58. Innerclass inner_2 = Out.getinnerclass (at "Chenssy");
60. System.out.println (Inner_2.getname ());
62. }
64. }

Accumulation of internal classes in Java