Java Internal classes

1) Inner class--a class within an external inner definition.

2) Inner classes can be static or public default protected and private adornments

Note: The inner class is just a compilation concept, and after the compilation is completed, it is two different classes, as in the outside.

3) Classification: member inner class, local inner class, nested inner class, anonymous inner classes

member Inner class: as a member of an external class, you can access the members and methods of the external class, even if it is private.

The external class accesses the members of the inner class and is accessed by the inner class object.

Note: The member inner class cannot contain static variables and methods. because the member inner class needs to create an external class before it can create its own ,

When a member's inner class is referencing an external class object, the Outer.this is used to represent the outer class object;

Instead, you need to create an inner class object that you can use outer.inner obj = outerobj.new inner ();

2. Public class Outer {
4. public static void Main (string[] args) {
6. Outer Outer = new Outer ();
8. Outer.Inner Inner = Outer. new Inner ();
10. Inner.print ("outer.new");
14. Inner = Outer.getinner ();
16. Inner.print ("Outer.get");
18. }
22. //Personal recommendation use GetXXX () to get a member inner class, especially if the constructor of the inner class has no arguments
24. Public Inner Getinner () {
26. return new Inner ();
28. }
32. public class Inner {
34. public void print (String str) {
36. System.out.println (str);
38. }
40. }
42. }

local inner class: refers to the inner class definition within the method and scope. Thinking in Java gives so two examples: defined within a method:

2. Public class Parcel4 {
4. Public Destination Destination (String s) {
6. class Pdestination implements Destination {
8. private String label;
12. Private Pdestination (String whereto) {
14. label = Whereto;
16. }
20. Public String Readlabel () {
22. return label;
24. }
26. }
28. return new Pdestination (s);
30. }
34. public static void Main (string[] args) {
36. Parcel4 p = new Parcel4 ();
38. Destination d = p.destination ("Tasmania");
40. }
42. }

2. Public class Parcel5 {
4. private void Internaltracking (boolean b) {
6. if (b) {
8. class Trackingslip {
10. private String ID;
12. Trackingslip (String s) {
14. ID = s;
16. }
18. String Getslip () {
20. return ID;
22. }
24. }
26. Trackingslip ts = new Trackingslip ("slip");
28. String s = ts.getslip ();
30. }
32. }
36. public void Track () {
38. Internaltracking (true);
40. }
44. public static void Main (string[] args) {
46. Parcel5 p = new Parcel5 ();
48. P.track ();
50. }
52. }

Local inner classes are compiled just like other classes, but only in different scopes, only within the scope of the method or condition, and cannot be referenced after exiting these scopes.

nested INNER classes: nested inner classes, which are inner class that are decorated as static. An inner class declared as static does not require a connection between an inner class object and an external class object, which means that we can refer directly to Outer.Inner, which means that you do not need to create an external class or create an inner class. There is another difference between nested classes and ordinary inner classes: ordinary inner classes cannot have static data and static properties, and cannot contain nested classes, but nested classes can. Nested classes cannot be declared private, and are generally declared public for easy invocation.

Anonymous inner class:

New parent class Constructor (parameter list) | Implement Interface ()
{
The class body part of an anonymous inner class
}

As can be seen from the above definition, an anonymous inner class must inherit a parent class, or implement an interface, but can inherit at most one parent class, or implement an interface.
There are two rules for anonymous inner classes:
1) An anonymous inner class cannot be an abstract class, because an object of an inner class is created immediately when the system creates an anonymous inner class. Anonymous internal classes are therefore not allowed
Defined as an abstract class.
2) anonymous inner classes do not define constructors because anonymous inner classes do not have class names, so constructors cannot be defined, but anonymous inner classes can define instance initialization blocks.

Java Internal classes