JAVA普通内部类的用法

　　内部类顾名思义就是定义在一个类的内部

　　内部类又有普通内部类、方法和域内的内部类、匿名内部类、嵌套内部类

普通内部类的基础用法

 1 class MyClass{
 2     class InnerClass1{
 3         public InnerClass1() {
 4             System.out.println("InnerClass1 created..");
 5         }
 6     }
 7     class InnerClass2{
 8         public InnerClass2() {
 9             System.out.println("InnerClass2 created..");
10         }
11     }
12     void getInnerClass() {
13         new InnerClass1();
14         new InnerClass2();
15     }
16     public static void main(String[] args) {
17         new MyClass().getInnerClass();
18     }
19 }
//输出：

InnerClass1 created..

InnerClass2 created..

上图就是一个普通内部类的例子，同时内部类自动拥有对其外围类所有成员的访问权。

main方法中获得内部类的实例需要借助其他方法，因为main方法是static的。

如果想要直接生成对外部类对象和内部类对象的引用，就需要借助.this和.new关键字。

.this关键字

 1 class MyClass{
 2     class InnerClass{
 3         public InnerClass() {
 4             System.out.println("InnerClass created..");
 5         }
 6         MyClass getMyClass() {
 7             System.out.println("getMyClass..");
 8             return MyClass.this;
 9         }
10     }
11     
12     InnerClass getInner() {
13         return new InnerClass();
14     }
15     public static void main(String[] args) {
16         MyClass mc=new MyClass();
17         MyClass.InnerClass mic=mc.getInner();
18         MyClass mc2=mic.getMyClass();
19     }
20 }

上例代码第8行，内部类通过.this关键字返回了一个MyClass对象。

.new关键字

上述普通内部类的第一个例子，我们得到一个内部类的对象是通过一个void方法。如果想要在main方法中直接获得实例可用

MyClass.InnerClass mic=new MyClass().new InnerClass();

内部类向上转型

内部类向上转型为一个接口时，内部类可以很好的隐藏起来。

 1 interface MyInterface{
 2     int getValue();
 3 }
 4 class MyClass{
 5     private class InnerClass implements MyInterface{
 6         public int getValue() {
 7             return 1024;
 8         }
 9 }
10     public MyInterface getInn() {
11         return new InnerClass();//内部类向上转型为接口
12     }
13     public static void main(String[] args) {
14         MyClass mClass=new MyClass();
15         System.out.println(mClass.getInn().getValue());
16     }
17 }