Java中的内部类_编程设计

一、总结

1.内部类简介
在一个类的内部重新定义一个新类就称为内部类。

内部类分为三种：
(1) 普通内部类：唯一好处就是可以方便的访问外部类的私有属性，同样外部类也可以方便的访问内部类的私有属性。

(2) 静态内部类：在普通内部类前面加static修饰。static内部类的唯一好处就是可以直接访问外部类的静态私有属性。

(3) 匿名内部类：假若一个类只使用一次，那么定义成匿名内部类比较省事。

使用：
普通内部类首先要实例化一个外部类对象，然后通过外部类对象实例化一个内部类对象。即使内部类中的所有的方法都没有访问外部类的属性，也需要遵守这个规则。
静态内部类可以直接通过“外部内.内部类对象 = new 外部内.内部类()”来实例化对象，eg：Outer.Inner i = new Outer.Inner();

2.内部类加static修饰，此时这个内部类就变成了外部类，它变为只能访问外部类的static的属性（eg: private static int a;）。此时可以不通过外部类直接创建内部类。

3.所有的static内部类只能访问外部类的static属性。类的static属性无论类是否实例化了对象都是存在的。不能通过实例化的对象.new 一个静态内部类，因为静态内部类不属于任何一个对象。

4.Android中大量使用static的内部类。

5.只有在内部类中才允许使用static修饰类，普通的类不可以是用static修饰。eg: 在一个类的内部是正确的，普通类是错误的 static class Stub { }

6. 内部类可声明成 public 或 private，当内部类声明成 public 或 private 时，对其访问的限制和成员变量和成员方法完全相同。

7. 内部类除了可以通过外部类访问外，还可以直接在其它类中进行调用，调用的基本格式：

外部类.内部类 内部类对象 = 外部类实例.new 内部类()

class Outer { 
    private String info = "Hello World!"; 
    class Inner { 
        public void print() { 
            System.out.println(info); 
        } 
    } 
} 
 
public class InnerClassTest { 
    public static void main(String args[]) { 
        Outer o = new Outer(); 
        Outer.Inner i = o.new Inner(); 
        i.print(); 
    } 
} 
 
# java InnerClassTest  
Hello World! 
# ls 
InnerClassTest.class  InnerClassTest.java  Outer.class  Outer$Inner.class

8. 观察内部类的class文件，可以发现，内部类定义之后生成的class文件是以 "Outer$Inner.class" 的形式存在的，在Java中只要在文件中看见了 "$"，则在程序中将其替换成 "."。

9. 理论上，内部类可以定义在程序的任何位置，例如代码块中、方法中。但是在方法中定义的内部类不能直接访问方法中的参数，如果方法中的参数想要被内部类访问，则参数前必须加上 final 关键字。注：JDK1.8 开始，即使不加 final 修饰也可以正常使用了。

class Outer { 
    private String info = "Hello World!"; 
    void func(final String str) { 
        class Inner { 
            public void print() { 
                System.out.println(info + str); 
            } 
        } 
        new Inner().print(); 
    } 
} 
 
public class InnerClassTest { 
    public static void main(String args[]) { 
        new Outer().func(" Baby"); 
    } 
} 
 
# java InnerClassTest  
Hello World! Baby

二、试验Demo

1. 内部类访问外部类私有属性，在类的外部使用内部类：

/*InnerDemo.java*/ 
 
class Outer { 
    private int a = 10; 
    class Inner { 
        public void printInfo(){ 
            System.out.println("a = "+a); 
        } 
    } 
     
} 
 
public class InnerDemo { 
    public static void main(String args[]) { 
        Outer o = new Outer(); 
        Outer.Inner i = o.new Inner(); 
        i.printInfo(); 
    } 
}

2. 静态内部类

/*InnerDemo2.java: Static Inner class*/ 
 
class Outer { 
    private static int a = 10; 
    static class Inner { 
        public void printInfo(){ 
            System.out.println("a = "+a); 
        } 
    } 
     
} 
 
public class InnerDemo2 { 
    public static void main(String args[]) { 
        //Outer o = new Outer(); 
        //Outer.Inner i = o.new Inner(); //This is error of static inner class 
        Outer.Inner i = new Outer.Inner(); 
        i.printInfo(); 
    } 
}

3. 对于只使用一次的new时重写初始化

/*InnerDemo3.java: Anonymous inner class*/ 
 
interface A { 
    public void printInfo(); 
} 
 
class B implements A { 
    public void printInfo() { 
        System.out.println("Hello, world!"); 
    } 
} 
 
 
public class InnerDemo3 { 
    public static void main(String args[])    { 
        testFunc(new B()); 
        testFunc(new A(){ //new A()的同时进行实例化 
            public void printInfo() { 
                System.out.println("Hello, world2!"); 
            } 
            }); 
    } 
 
    public static void testFunc(A a) { 
        a.printInfo(); 
    } 
}

本文参考链接：https://www.cnblogs.com/hellokitty2/p/10425525.html