Detailed explanation of example code of Java basic internal classes

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 For one of the organs, such as the heart: it also has its own properties and behavior (blood, beating)

Obviously, it cannot be used unilaterally here The attribute or method represents a heart, and a class is required

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

Example 1: The basic structure of the inner 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();
    */
  }
}

Running result: 12

It is not difficult to see from the above example that inner classes actually seriously damage the good code structure, but why should they be used? What about inner classes?

Because the inner class can freely use the members of the outer class Variables (including private) without generating the object of the outer class, this is the only advantage of the inner class

Just like the heart can directly access the body's blood 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 the one in Out.In in the above program.

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

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

2. There must be an object of the external class before it can be generated The object of the inner class, because the function of the inner class is to access the member variables in the outer class

Example 2: Variable access form in the inner class

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 instance 1 that the internal class is not In the case of member variables and local variables with the same name, the inner class will directly access the member variables of the outer class without specifying Out.this. attribute name

Otherwise, the local variables in the inner class will overwrite the members of the outer class. Variable

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

Example 3: StaticInner 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();
  }
}

Run result:12

As you can see, if you use static to make the internal class static, then the internal class will only Being able to access static member variables of the outer class has limitations

Secondly, because the inner class is staticized, Out.In can be viewed as a whole, and the object of the inner class can be directly new (accessed through the class name static, it doesn’t matter whether an external class object is generated or not)

Example 4: Private internal 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();
  }
}

Run result: 12

If an inner class only wants to be operated by methods in the outer class, you can use private to declare the inner class.

In the above code, we must generate an object of the In class in the Out class for operation, but cannot Then use Out.In in = new Out().new In() to generate the object of the inner class

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

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

Instance 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);
  }
}

Running 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. Calling the inner class method

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

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

The above is the detailed content of Detailed explanation of example code of Java basic internal classes. For more information, please follow other related articles on the PHP Chinese website!