Java SE 内部类

内部类

1. 什么是内部类

将类写在其他类的内部，可以写在其他的成员位置和其他类的局部位置，这时写在其他 类内部的类就称为内部类。

2. 什么时候使用内部类

在描述事物，若一个事物内部还包含其他可能包含的事物，内部事物必须寄宿在外部事物内部。

3. 内部类代码体现

class Outer{ 
    //外部类的成员变量 
    int num = 10; 
    //写在Outer成员位置上的内部类 
    class Inner{
        //内部类的成员函数 
        void show(){ 
            //在内部类中访问外部类的成员变量
            System.out.println("Outer num = "+num);
        } 
    } 
}

4. 内部类访问规则

内部类可以直接访问外部类中的成员，但外部类不能直接访问内部类，若要访问，必须创建内部类对象才能访问

class Outer{ 
    //外部类的成员变量 
    int num = 10; 
    //写在Outer成员位置上的内部类 
    class Inner{ 
        //内部类的成员函数 
        void show(){ 
        //在内部类中访问外部类的成员变量 
            System.out.println("Outer num = "+num); 
        } 
    }
    public void method(){ 
        //创建内部类对象，访问内部类的成员函数或者变量 
        Inner in = new Inner(); 
        in.show(); 
    } 
}
public class Main { 
    public static void main(String[] args) { 
        Outer out = new Outer(); 
        out.method(); 
    } 
}

5. 内部类创建对象

当内部类在外部类成员位置上的时候，内部类就是外部类成员的一份子。这时这个内部类就可以使用成员修饰符修饰，比如public、static、private

1. 非静态非私有内部类
   如果内部类的权限是非私有的，就可以在外部类以外的其他类中访问。即可以通过创建外部类对完成访问内部类。
   比如以上程序：

   class Outer{ 
       //外部类的成员变量 
       int num = 10; 
       //写在Outer成员位置上的内部类 
       class Inner{ 
           //内部类的成员函数 
           void show(){ 
           //在内部类中访问外部类的成员变量 
               System.out.println("Outer num = "+ num); 
           } 
       }
   }
   public class Main { 
       public static void main(String[] args) { 
           //通过创建外部类对象，接着创建内部类对象 
           Outer.Inner in = new Outer().new Inner(); 
           in.show();
       } 
   }
   

2. 静态的非私有内部类

   当内部类在外部类成员位置上被static修饰时，由于静态可以直接使用类名调用。

   class Outer{ 
       //外部类的成员变量 （成员变量必须为静态）
       static int num = 10; 
       //写在Outer成员位置上的静态内部类 
       static class Inner{ 
           //内部类的成员函数 
           void show(){ 
           	//在内部类中访问外部类的成员变量 
               System.out.println("Outer num = "+ num); 
           } 
       }
   }
   public class Main { 
       public static void main(String[] args) { 
           //因为内部类是静态，所以不需要创建Outer的对象。直接创建内部类对象。
           Outer.Inner in = new Outer.Inner(); 
           in.show();
       } 
   }
   

3. 访问静态内部类的静态成员

   由于内部类是静态的，可以直接使用外部类名调用内部类，而内部类的成员也是静态

   的，这时同样可以通过类名调用内部类的静态成员。

   class Outer{
   	//外部类的成员变量（成员变量必须为静态）
       static int num = 10;
       //写在Outer成员位置上的静态内部类 
       static class Inner{ 
           //内部类的成员函数 
           static void show(){ 
               //内部类的静态方法 
               System.out.println("static Inner method num = "+ num); 
           }
       }
   }
   public class Main { 
   	public static void main(String[] args) { 
   		//静态成员随着类的加载而加载，就不需要 对象，直接用类名调用即可
   		Outer.Inner.show();
       } 
   }
   

6.内部类成员函数访问内部类局部变量、内部类的成员变量、外部类的成员变量

class Outer { 
	int num = 10;// 外部类的成员变量 
    class Inner { 
        int num = 20;// 内部类的成员变量 
        void show() { 
            int num = 30; // 内部类局部变量 
            //内部类成员函数访问局部变量
            System.out.println("内部类局部num=" + num);
            
			//内部类成员函数访问内部类的成员变量
            System.out.println("内部类成员num=" + this.num); 
            
            //内部类成员函数访问外部类的成员变量
            //内部类持有外部类的引用（外部类.this）
            System.out.println("外部类成员num=" + Outer.this.num); 
        }
    }
}