Understand Java internal classes in 10 minutes

Depending on how they are defined, inner classes are divided into four types: static inner classes, member inner classes, local inner classes, and anonymous inner classes.

1. Static inner class

A static class defined inside a class is a static inner class.

public class Out {
     private static int a;
     private int b;
     public static class Inner {
         public void print() {
             System.out.println(a);
         }
     }
}

1) Static inner classes can access all static variables and methods of outer classes, even private ones.

(Recommended video: java video tutorial)

2) Static inner class and Generally, classes are consistent and can define static variables, methods, constructors, etc.

3) Other classes that use static inner classes need to use the "external class. static inner class" method. As shown below: Out.Inner inner = new Out.Inner(); inner.print();

4) There is a static inner class Entry inside the Java collection class HashMap. Entry is an abstraction for HashMap to store elements. HashMap maintains an Entry array internally to store elements, but Entry is transparent to users. Static inner classes can be used if they are closely related to external classes and do not depend on external class instances.

2. Member inner class

A non-static class defined inside a class is a member inner class. Member inner classes cannot define static methods and variables (except those modified by final). This is because the member inner class is non-static. When the class is initialized, the static members are initialized first. If the member inner class is allowed to define static variables, then the initialization order of the static variables of the member inner class is ambiguous.

public class Out {
     private static int a;
     private int b;
     public class Inner {
         public void print() {
             System.out.println(a);
             System.out.println(b);
         }
     }
}

3. Local internal class (class defined in the method)

The class defined in the method is a local class. If a class is only used within a certain method, consider using a local class.

public class Out {
     private static int a;
     private int b;
     public void test(final int c) {
         final int d = 1;
         class Inner {
             public void print() {
                 System.out.println(c);
             }
         }
     }
}

4. Anonymous internal class (to inherit a parent class or implement an interface, use new directly to generate a reference to an object)

Anonymous internal class For a class, we must inherit a parent class or implement an interface. Of course, we can only inherit one parent class or implement an interface. At the same time, it does not have the class keyword, because anonymous inner classes directly use new to generate a reference to an object.

1) Anonymous inner classes can only be used once. When creating an anonymous inner class, it will immediately create an instance of the class. The definition of the class will disappear immediately, so the anonymous inner class cannot be repeated. in use.

2) Anonymous inner classes cannot define constructors, and cannot have any static member variables and static methods.

3) The method in the anonymous inner class cannot be abstract. It must implement the interface or inherit all abstract methods of the parent class.

4) The member variables or member methods of the outer class accessed by the anonymous inner class must be modified with static. The inner class can access the private variables and methods of the outer class.

public abstract class Bird {
     private String name;
     public String getName() {
         return name;
     }
     public void setName(String name) {
         this.name = name;
     }
     public abstract int fly();
}
public class Test {
     public void test(Bird bird){
         System.out.println(bird.getName() + "能够飞 " + bird.fly() + "米");
     }
     public static void main(String[] args) {
         Test test = new Test();
         test.test(new Bird() {
             public int fly() {
                 return 10000;
             }
             public String getName() {
                 return "大雁";
             }
         });
         }
}

This article comes from php Chinese website, java tutorial column, welcome to learn!

The above is the detailed content of Understand Java internal classes in 10 minutes. For more information, please follow other related articles on the PHP Chinese website!