Detailed explanation of internal class instances of Java basics

This article mainly introduces the detailed explanation and examples of Java basic internal classes. Friends who need it can refer to

The detailed explanation and examples of Java basic internal classes

Internal classes are not easy to understand, but to put it bluntly, one class actually contains another class

Just like a person is composed of brain, limbs, organs and other body parts, and internal classes are quite One of the organs, such as the heart: it also has its own attributes and behaviors (blood, beating)

Obviously, a heart cannot be represented unilaterally by attributes or methods here, but a class is required

And the heart is in the human body, just like the internal class is inside the outside

Example 1: The basic structure of the internal class

//外部类
class Out {
  private int age = 12;  
  //内部类
  class In {
    public void print() {
      System.out.println(age);
    }
  }
}
 
public class Demo {
  public static void main(String[] args) {
    Out.In in = new Out().new In();
    in.print();
    //或者采用下种方式访问
    /*
    Out out = new Out();
    Out.In in = out.new In();
    in.print();
    */
  }
}

Run results : 12

It is not difficult to see from the above example that inner classes actually seriously damage the good code structure, but why should we still use inner classes?

Because the inner class can freely use the member variables of the outer class (including private) without generating objects of the outer class, this is the only advantage of the inner class

Just like the heart can directly access the blood of the body , instead of drawing blood through a doctor

After the program is compiled, two .class files will be generated, namely Out.class and Out$In.class

where $ represents Out in the above program The one in .In.

Out.In in = new Out().new In() can be used to generate objects of inner classes. There are two small knowledge points that need to be paid attention to in this method

1. The Out at the beginning is to indicate which external class the internal class object that needs to be generated is in.

2. There must be an object of the external class before the object of the internal class can be generated, because the function of the internal class is to Access member variables in external classes

Example 2: Variable access form in internal classes

class Out {
  private int age = 12;
   
  class In {
    private int age = 13;
    public void print() {
      int age = 14;
      System.out.println("局部变量：" + age);
      System.out.println("内部类变量：" + this.age);
      System.out.println("外部类变量：" + Out.this.age);
    }
  }
}
 
public class Demo {
  public static void main(String[] args) {
    Out.In in = new Out().new In();
    in.print();
  }
}

Running results:

Local variables :14
Internal class variables: 13
External class variables: 12

It can be found from Example 1 that when the inner class does not have member variables and local variables with the same name, the inner class Will directly access the member variables of the outer class without specifying the Out.this. attribute name

Otherwise, the local variables in the inner class will overwrite the member variables of the outer class

and access the inner class itself The member variables can use this.property name. To access the member variables of the external class, you need to use the Out.this.property name

Example 3: Static inner class

class Out {
  private static int age = 12;
   
  static class In {
    public void print() {
      System.out.println(age);
    }
  }
}
 
public class Demo {
  public static void main(String[] args) {
    Out.In in = new Out.In();
    in.print();
  }
}

Running result : 12

You can see that if you use static to make the internal static, then the internal class can only access the static member variables of the external class, which has limitations

Secondly, because the inner class is static, Out.In can be viewed as a whole, and the object of the inner class can be directly newed (static is accessed through the class name, and it does not matter whether the outer class object is generated or not)

Example 4: Private inner class

class Out {
  private int age = 12;
   
  private class In {
    public void print() {
      System.out.println(age);
    }
  }
  public void outPrint() {
    new In().print();
  }
}
 
public class Demo {
  public static void main(String[] args) {
    //此方法无效
    /*
    Out.In in = new Out().new In();
    in.print();
    */
    Out out = new Out();
    out.outPrint();
  }
}

Running result:12

If an inner class only wants to be operated by methods in the outer class, then it can Use private to declare internal classes

In the above code, we must generate an object of In class in Out class for operation, and we can no longer use Out.In in = new Out().new In() to generate internal Class object

That is to say, the inner class at this time can only be controlled by the outer class

Like, my heart can only be controlled by my body, and others cannot directly access it

Example 5: Method inner class

class Out {
  private int age = 12;
 
  public void Print(final int x) {
    class In {
      public void inPrint() {
        System.out.println(x);
        System.out.println(age);
      }
    }
    new In().inPrint();
  }
}
 
public class Demo {
  public static void main(String[] args) {
    Out out = new Out();
    out.Print(3);
  }
}

Run result:

3
12

In the above code, we moved the inner class to the method of the outer class, and then generated an inner class object in the method of the outer class to call the inner class method

If we need to call the outer class method at this time If parameters are passed into the method, then the method parameters of the external class must be defined using final

As for final, there is no special meaning here, it is just a form of expression.

The above is the detailed content of Detailed explanation of internal class instances of Java basics. For more information, please follow other related articles on the PHP Chinese website!