Java—内部类

内部类的概念

1.概念：内部类定义在方法中，或者是定义在类中的类；

2.分类：

　　成员内部类：普通成员内部类，私有成员内部类以及静态内部类；

　　局部内部类：定义在方法中的内部类；

　　匿名内部类：没有名称的内部类；

3.解释

　　（1）普通成员内部类：定义在类中，方法外；、

　　　　语法：访问修饰符 class 外部类名{

　　　　　　　　访问修饰符 class 内部类名{

　　　　　　　　　　}

　　　　说明：

　　　　　　A.静态内部类只能访问外部类的静态资源；

　　　　　　B.外部类访问内部类的资源时：

　　　　　　　　a.如果访问的是非静态资源，需要实例化对象之后，通过对象名访问；

　　　　　　　　b.如果访问的是静态资源，则直接通过类名来访问；

　　　　　　C.外部类以外的类也可以访问内部类的资源；

　　　　　　　　访问语法：外部类.内部类对象名 = new 外部类.内部类（）；

　　　　　　　　例子：OutClass.Inner in = new OutClass.Inner();

　　（2）局部内部类：定义在方法中；

　　　　　语法：访问修饰符返回值类型方法名称（）{

　　　　　　　　class 内部类名{

　　　　　　　　　　}

　　　　　说明：局部内部类和外部类只能间接访问资源

　　（3）匿名内部类：没有名称的内部类

　　　　　前提：是实例化接口（实现类）或者是抽象类（子类）；　　

案例：

 1 //普通成员内部类
 2 //外部类OutClas
 3 class OutClass{
 4     //定义外部类私有变量num
 5     private int num=100;
 6     //声明外部类方法show
 7     public void show(){
 8         Inner in = new Inner();
 9         System.out.println(in.num1);
10     }
11     //声明内部类
12     public class Inner{
13         //定义内部类私有变量num1
14         private int num1=100;
15         //声明内部类的方法showInfo
16         public void showInfo(){
17             //输出外部类OutClass的私有成员变量
18             System.out.println(num);
19         }
20     }
21 }
22 
23 //测试类
24 public class Test11 {
25     public static void main(String[] args) {
26         //实例化内部类对象
27         OutClass.Inner in = new OutClass().new Inner();
28         in.showInfo();
29     }
30 }

 1 //私有成员内部类 内部类不能被外部类使用
 2 //外部类OutClass
 3 class OutClass{
 4     //外部类OutClass的私有变量
 5     private int num=10;
 6     //外部类OutClass的show方法
 7     public void show(){
 8         //实例化对象
 9         InnerClass in = new InnerClass();
10         //输出内部类InnerClass的私有成员变量
11         System.out.println(in.num1);
12     }
13     //声明内部类InnerClass
14     private class InnerClass{
15         //声明内部类InnerClass的私有成员变量
16         private int num1=100;
17         //声明内部类方法
18         private void showInfo(){
19             //输出外部类OutClass的私有变量
20             System.out.println(num);
21         }
22     }
23 }

 1 //静态内部类
 2 //OutClass外部类
 3 class OutClass{
 4     //私有变量
 5     private int num=10;
 6     private static int num1=100;
 7     //外部类方法
 8     public void showInfo(){
 9         Inner in = new Inner();
10         System.out.println(in.num2);
11         System.out.println(Inner.num3);
12     }
13     //内部静态类
14     static class Inner{
15         private int num2=200;
16         private static int num3=400;
17         //内部类方法
18         public void showInfo(){
19             System.out.println(num1);
20         }
21     }
22 }

 1 //局部内部类
 2 class OutClass{
 3     //外部类方法
 4     public void showInfo(){
 5         //方法内定义局部内部类
 6         class Inner{
 7             private int num=100;
 8             public void show(){
 9                 System.out.println("这里是Inner内部类");
10             }
11         }
12         //showInfo方法内实例化对象
13         Inner in = new Inner();
14         in.show();
15     }
16 }
17 //测试类
18 public class Test12 {
19     public static void main(String[] args) {
20         //实例化对象
21         OutClass out  = new OutClass();
22         out.showInfo();
23     }
24 }

 1 //匿名内部类-接口
 2 interface OutClass{
 3     void showInfo();
 4 }
 5 //匿名内部类-接口-测试类
 6 public class Test12 {
 7     public static void main(String[] args) {
 8         new OutClass(){
 9             @Override
10             public void showInfo(){
11                 System.out.println("这里是匿名内部类-接口-测试类");
12             }
13         }.showInfo();
14     }
15 }

 1 //匿名内部类-抽象类
 2 interface OutClass{
 3     public abstract void showInfo();
 4 }
 5 //匿名内部类-抽象类-测试类
 6 public class Test12 {
 7     public static void main(String[] args) {
 8         new OutClass(){
 9             @Override
10             public void showInfo(){
11                 System.out.println("这里是匿名内部类-抽象类-测试类");
12             }
13         }.showInfo();
14     }
15 }