目录

1、基本概念

2、static定义内部类

3、方法中定义内部类

4、总结

1、基本概念

类的组成包括：成员、方法，几乎所有程序都不会对嵌套程序有什么限定，内部类指的是在一个类中继续嵌套其他类结构的一种代码形式，且理论上可以一直嵌套。

【举例】：观察内部类

      public class MainActivity extends AppCompatActivity {
         @Override
         protected void onCreate(Bundle savedInstanceState) {
             super.onCreate(savedInstanceState);
              Outer o = new Outer();
              o.fun();
          }
      }
      class Outer{ //外部类
         private String info = "hello";
         class Inner{ //内部类
             public void print(){
                  System.out.println(info);
              }
          }
         public void fun(){
              Inner inner = new Inner();
              inner.print();
          }
      }
  
 

类本身的核心组成就应该是属性和方法，但是引用了内部类的话，程序结构就被破坏了，那么内部类的好处在哪？若将内部类拿出，变为两个类，程序改动非常大，内部类的最大好处就是可以直接进行外部类的私有属性访问。

现在有以下几个问题：

（1）在编写代码中，只要是属性的访问，一定要加this，但由于属性是外部类的，所以需要：外部类.this.属性；

      class Outer{ //外部类
         private String info = "hello";
         class Inner{ //内部类
             public void print(){
                  System.out.println(Outer.this.info);
              }
          }
         public void fun(){
              Inner inner = new Inner();
              inner.print();
          }
      }
  
 

（2）以上代码，内部类可以方便操作外部类私有属性，那么外部类是否可以访问内部类的私有属性：答案，是

        protected void onCreate(Bundle savedInstanceState) {
             super.onCreate(savedInstanceState);
              Outer o = new Outer();
              o.fun();
          }
      class Outer{ //外部类
         private String info = "hello";
         class Inner{ //内部类
             private String msg = "world";
             public void print(){
                  System.out.println(Outer.this.info);
              }
          }
         public void fun(){
              Inner inner = new Inner();
              inner.print();
              System.out.println(inner.msg);
          }
      }
  
 

由以上可知，内部类和外部类的私有属性是可以直接访问的。

（3）目前可发现，实例化内部类的对象操作都是在外部类的fun()方法里面完成的，其他类是否可以直接操作内部类对象，在其他类中实例化内部类对象，语法如下：

• 外部类名称.内部类名称 对象名称 = new 外部类().new 内部类()；

      public class MainActivity extends AppCompatActivity {
         @Override
         protected void onCreate(Bundle savedInstanceState) {
             super.onCreate(savedInstanceState);
              Outer.Inner inner = new Outer().new Inner();
              inner.print();
          }
      }
      class Outer{ //外部类
         private String info = "hello";
         class Inner{ //内部类
             private String msg = "world";
             public void print(){
                  System.out.println(Outer.this.info);
              }
          }
         public void fun(){
              Inner inner = new Inner();
              inner.print();
              System.out.println(inner.msg);
          }
      }
  
 

（4）内部类可以通过private定义为私有内部类，仅可以被其外部类使用

      class Outer{ //外部类
         private String info = "hello";
         private class Inner{ //内部类
             private String msg = "world";
             public void print(){
                  System.out.println(Outer.this.info);
              }
          }
         public void fun(){
              Inner inner = new Inner();
              inner.print();
              System.out.println(inner.msg);
          }
      }
  
 

2、static定义内部类

利用static定义的 属性和方法是不受类的控制的，相当于一个局外结构，如果内部类使用了static定义，那么此内部类就相当于变成了外部类，只能访问外部类的static属性。

【举例】：利用static定义内部类

      class Outer{ //外部类
         private static String info = "hello";
         static class Inner{ //static内部类 = 外部类
             private String msg = "world";
             public void print(){
                  System.out.println(info);
              }
          }
         public void fun(){
              Inner inner = new Inner();
              inner.print();
              System.out.println(inner.msg);
          }
      }
  
 

既然static内部类变成了外部类，那么外部类就可以被其他类直接进行操作。但是这时候的实例化格式为：

• 外部类名称.内部类名称 对象名称 = new 外部类.内部类()；

               Outer.Inner inner = new Outer.Inner();
               inner.print();
   
  

       public class MainActivity extends AppCompatActivity {
          @Override
          protected void onCreate(Bundle savedInstanceState) {
              super.onCreate(savedInstanceState);
               Outer outer = new Outer();
               outer.fun(100);
           }
       }
       class Outer{ //外部类
          private  String info = "hello";
          public void fun(int temp){
              double sal = 9000.0;
              class Inner{
                  public void print(){
                       System.out.println("Outer类中的info属性="+Outer.this.info);
                       System.out.println("fun()方法中的参数temp="+temp);
                       System.out.println("fun()方法中定义的临时变量sal="+sal);
                   }
               }
              new Inner().print();
           }
       }
   
  

文章来源: winter.blog.csdn.net，作者：Winter_world，版权归原作者所有，如需转载，请联系作者。

原文链接：winter.blog.csdn.net/article/details/105375508