JAVA内部类

内部类是一种类的结果扩充，一个类的内部除了属性和方法外，还可以存在其他类的结构，并且内部类也可以定义在方法或代码块中。

1. 基本概念

   所谓的内部类指的就是在一个类的内部继续定义其他内部结构类

   观察内部类的基本形式：

   package oop;
   ​
   /**
    * 观察内部类的基本形式
    */
   class Outer{//外部类
       private String msg="Hello World!";//属性
       class Inner{//内部类
           public void print(){
               System.out.println(msg);
           }
       }
       public void fun(){
           new Inner().print();
       }
   ​
   }
   public class TestDeno{
       public static void main(String[] args) {
           Outer out=new Outer();//实例化对象
           out.fun();
       }
   }
   ​

   内部类的基本形式就是将类的定义拿到类的内部，也就是说除了属性和方法外，也可以定义属于自己内部的结构体。这样做最大的缺点在于破坏了类的结构性。它最大的帮助就是可以轻松地访问外部类中的私有属性。

   将内部类放在外部并且实现同样功能：

   package oop;
   ​
   /**
    * 将内部类放在外部同样实现此功能
    */
   class Outer1{
       private String msg="Hello World!";//属性
       public void fun(){
           //this表示当前调用fun()方法的对象，在本程序中主方法由Out对象调用，所以this就是out
           new Inner1(this).print();//实例化对象调用print()方法
       }
       //内部类需要访问msg属性，但是此属性属于Outer1类，而在Outer1类里面此属性使用Private进行封装
       //所以如果此时要得到这个属性的内容，需要定义一个getter方法
       public String getMsg(){
           return this.msg;
       }
   }
   class Inner1{
       private Outer1 out;//必须依靠对象才可以调用getMsg()方法
       public Inner1(Outer1 out){//在构造方法中接收外部类对象
           this.out=out;
       }
       public void print(){
           System.out.println(this.out.getMsg());
       }
   }
   public class TestDemo {
       public static void main(String[] args) {
           Outer1 out=new Outer1();
           out.fun();
       }
   }
   ​

   所以内部类的最大好处就是可以方便地访问外部类中的私有属性。

   外部类访问内部类的私有属性：

   package oop;
   ​
   /**
    * 访问内部类的私有属性
    */
   class Outer2{
       private String msg="Hello World!";
       class Inner2{
           private String info="世界 你好!";
           public void print(){
               System.out.println(Outer2.this.msg);
           }
       }
       public void fun(){
           Inner2 in=new Inner2();
           System.out.println(in.info);
           in.print();
       }
   }
   public class TestDemo{
       public static void main(String[] args) {
           Outer2 out=new Outer2();
           out.fun();
   ​
       }
   }
   ​

   外部类可以直接利用内部类的对象使用"对象.属性"的形式访问私有属性操作。

   内部类对象的实例化语法操作：

   外部类.内部类  对象=new 外部类().new 内部类();

   内部类对象的实例化语法格式只是一个基础，指的是在一个内部类只定义一个内部类的情况，而如果一个内部类中又定义了内部类，则类结构需要继续向下延伸：

   外部类.内部类1.内部类2 对象=new 外部类().new 内部类1().new 内部类2();

   实例化内部类对象:

   package oop;
   ​
   /**
    * 实例化内部类对象
    */
   class Outer3{
       private String msg="Hello World!";
       class Inner3{
           private String in="罗小齐草泥马！";
           public void print(){
               System.out.println(Outer3.this.msg);
               System.out.println(in);
           }
       }
   }
   public class TestDemo {
       public static void main(String[] args) {
           Outer3.Inner3 in=new Outer3().new Inner3();
           in.print();
       }
   }
   ​

   如果一个内部类只希望被一个外部类访问，不能被外部调用，那么可以使用private定义私有内部类

2. 使用static定义内部类

   使用static定义的属性或方法是不受实例化对象控制的，所以如果使用static定义内部类，它一定不可能受到外部类的实例化对象控制

   如果一个内部类使用static定义，那么这个内部类就变为一个"外部类",并且只能访问外部类中定义的static操作。相当于定义一个外部类。

   使用如果想要取得内部类的实例化对象，其语法格式如下：

   外部类.内部类 对象=new 外部类.内部类();

   实例化"外部类"对象：

   package oop;
   /**
    * 使用static定义内部类
    */
   class Outer4{
       private static String msg="Hello World!";
       static class Inner4{
           private String in="HelloWorld!";
           public void print(){
               System.out.println(Outer4.msg);
               System.out.println(in);
           }
       }
   }
   public class TestDemo {
       public static void main(String[] args) {
           Outer4.Inner4 in=new Outer4.Inner4();
           in.print();
       }
   }
   ​

   ---

   实例化内部类的操作有如下两种格式：

   • 格式一(非static定义的内部类):

     外部类.内部类  内部类对象=new 外部类().new 内部类();

   • 格式二(static定义内部类)：

     外部类.内部类 内部类对象=new 外部类.内部类();

3. 在方法中定义内部类

内部类理论上可以在类的任意位置上进行定义，包括在代码块中，或在普通方法中。

在普通方法中定义内部类:

package oop;
​
/**
 * 在方法中定义内部类
 */
class Outer5{
    private String msg="Hello World!";
    public void fun(){
        class Inner5{
            private String in="今天天气很适合在家敲代码！";
            public void print(){
                System.out.println(Outer5.this.msg);
                System.out.println(in);
            }
        }
        new Inner5().print();
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Outer5 out=new Outer5();
        out.fun();
    }
}
​

访问方法中定义的参数或变量：

package oop;
​
/**
 * 访问方法中内部类定义的参数或变量
 */
class Outer6{
    private String msg="Hello World!";
    public void fun(int num){
        double score=99.9;
        class Inner6{
            private String in="今天天气真好";
            public void print(){
                System.out.println(in);
                System.out.println("属性："+Outer6.this.msg);
                System.out.println("方法参数:"+num);
                System.out.println("方法变量:"+score);
​
            }
        }
        new Inner6().print();
    }
}
public class TestDemo {
​
    public static void main(String[] args) {
        Outer6 out=new Outer6();
        out.fun(100);
    }
}
​