Java Internal classes

Java Internal class summary

Java has a lot of internal class content, not very well understood, but plainly speaking is also a class containing another class.

The basic structure of the inner class

Let's take a look at a piece of code before explaining it.

2. class Out { //External class
4. Private int Age = N;
8. class In { //inner class
10. Public void Print () {
12. System. Out. println (age);
14. }
16. }
18. }
22. Public class Demo {
24. Public Static void Main (String[] args) {
26. Out. In in = new out (). New inch ();
28. inch . Print ();
30. //or using sowing mode to access
32. /*
34. out = new Out ();
36. Out.in in = Out.new in ();
38. In.print ();
40. */
42. }
44. }
46. /* Run Result: 12 */

From the above example, it is not difficult to see that the inner class actually seriously destroys the good code structure, but why use the inner class? This is the only advantage of an inner class because the inner class is free to use the member variables of the outer class, including the private ones, without generating an object of the outer class.

After the program compiles, two. class files are generated, respectively, Out.class and out$in.class, where $ represents the out.inin the above program.

out.in in = new Out (). The new in () can be used to generate an object of the inner class, which has two small knowledge points to note.

1. The first out is to indicate which outer class the inner class object is to be generated in.
2. An object of an outer class must be preceded to generate an object of the inner class . Because an inner class can access member variables in an external class, a null pointer exception occurs if the outer class is not instantiated. (But the compiler doesn't allow this to happen.)

PS: C # is not the same as Java, where the inner class of C # cannot access the non-static content of the outer class. C # Inner classes are equivalent to static internal classes of Java

The Access form of variables in the inner class

Access the member variables of the inner class itself directly this . The property name is allowed, and the member variable that accesses the external class needs to use out.this. Property name

2. class Out {
4. Private int Age = N;
8. class In {
10. Private int Age = ;
12. Public void Print () {
14. int Age = +;
16. System. Out. println ("local variable:" + age);
18. System. Out. println ("inner class variable:" + this. ) Age);
20. System. Out. println ("outer class variable:" + out. ) This . Age);
22. }
24. }
26. }
30. Public class Demo {
32. Public Static void Main (String[] args) {
34. Out. In in = new out (). New inch ();
36. inch . Print ();
38. }
40. }
42. /*
44. Operation Result:
46. Local variables: 14
48. Internal class variable: 13
50. External class variables: 12
52. */

Static Inner class

2. class Out {
4. private static int Age = N;
8. Static Class In {
10. Public void Print () {
12. System. Out. println (age);
14. }
16. }
18. }
22. Public class Demo {
24. Public Static void Main (String[] args) {
26. Out. In the = new out. inch ();
28. inch . Print ();
30. }
32. }
34. /* Run Result: 12*/

As you can see , static internal classes can be statically used with static, and the inner classes that are statically built can only access static member variables of the outer class , and have limitations.

Second, because the inner class is statically, the out.in can be viewed as a whole. In short , you can directly new the object of the inner class .

Private Inner class

If you want an inner class to operate only in an external class, you can use private to decorate the inner class.

2. class Out {
4. Private int Age = N;
8. Private Class In {
10. Public void Print () {
12. System. Out. println (age);
14. }
16. }
18. Public void Outprint () {
20. New inch (). Print ();
22. }
24. }
28. Public class Demo {
30. Public Static void Main (String[] args) {
32. //This method is invalid
34. /*
36. Out.in in = new Out (). New in ();
38. In.print ();
40. */
42. Out = new out ();
44. Out. Outprint ();
46. }
48. }
52. /* Run Result: 12*/

In the above code, we can only manipulate objects generated by the in class within the out class , and can no longer use out.in in = new Out (). New in () to generate an object of the inner class.

In other words, the inner class at this point can only be controlled by the outer class.

Java Internal classes