Java基础：29 内部类

1、类的内部成员之五： 内部类

当一个事物的内部，还有一个部分需要一个完整的结构进行描述，而这个内部的完整的结构又只为外部事物提供服务，那么整个内部的完整结构最好使用内部类。
在Java中，允许一个类的定义位于另一个类的内部，前者称为内部类，后者称为外部类。
Inner class一般用在定义它的类或语句块之内，在外部引用它时必须给出完整的名称。
Inner class的名字不能与包含它的外部类类名相同

2、分类

1. 成员内部类（static成员内部类和非static成员内部类）
2. 局部内部类（不谈修饰符）
3. 匿名内部类

3、成员内部类

成员内部类有两层性质，一是它是外部类的成员，二是它本身就是一个类。

成员内部类作为外部类的成员：

• 和外部类不同，Inner class还可以声明为private或protected。
• 可以调用外部类的结构。
• 可以声明为static的，但此时就不能再使用外层类的非static的成员变量。

成员内部类作为类：

• 可以在内部定义属性、方法、构造器等结构
• 可以声明为abstract类 ，因此可以被其它的内部类继承
• 可以声明为final的
• 编译以后生成OuterClass$InnerClass.class字节码文件（也适用于局部内部类）

注意：

1. 非static的成员内部类中的成员不能声明为static的，只有在外部类或static的成员内部类中才可声明static成员。
2. 外部类访问成员内部类的成员，需要“内部类.成员”或“内部类对象.成员”的方式。
3. 成员内部类可以直接使用外部类的所有成员，包括私有的数据。
4. 当想要在外部类的静态成员部分使用内部类时，可以考虑内部类声明为静态的。

Demo1：

class Outer { 
        private int s; 
        public class Inner { 
            public void mb() { 
                s = 100; 
                System.out.println("在内部类Inner中s=" + s); 
            } 
        } 
        public void ma() { 
            Inner i = new Inner(); 
            i.mb(); 
        } 
} 
public class InnerTest { 
    public static void main(String args[]) { 
         Outer o = new Outer(); 
         o.ma(); //在内部类Inner中s=100
    } 
}

Demo2：

public class Outer { 
    private int s = 111; 
    public class Inner { 
        private int s = 222; 
        public void mb(int s) { 
            System.out.println(s); // 局部变量s 
            System.out.println(this.s); // 内部类对象的属性s 
            System.out.println(Outer.this.s); // 外部类对象属性s 
        } 
    } 
    public static void main(String args[]) { 
        Outer a = new Outer(); 
        Outer.Inner b = a.new Inner(); 
        b.mb(333); 
    } 
}

运行结果：

333
222
111

Demo3：

public class Test { 
    public Test() { 
        Inner s1 = new Inner(); 
        s1.a = 10; 
        Inner s2 = new Inner(); 
        s2.a = 20; 
        Test.Inner s3 = new Test.Inner(); 
        System.out.println(s3.a); 
    } 
    class Inner { 
        public int a = 5; 
    } 
    public static void main(String[] args) { 
        Test t = new Test(); 
        Inner r = t.new Inner(); 
        System.out.println(r.a); 
    } 
}

运行结果：

5
5

4、局部内部类

class 外部类{ 
    方法(){ 
        class 局部内部类{ } 
    } 
    { 
        class 局部内部类{ } 
    }
}

局部内部类的使用：

• 只能在声明它的方法或代码块中使用，而且是先声明后使用。除此之外的任何地方都不能使用该类。但是它的对象可以通过外部方法的返回值返回使用，返回值类型只能是局部内部类的父类或父接口类型。

局部内部类的特点：

• 内部类仍然是一个独立的类，在编译之后内部类会被编译成独立的.class文件，但是前面冠以外部类的类名和$符号，以及数字编号。
• 只能在声明它的方法或代码块中使用，而且是先声明后使用。除此之外的任何地方都不能使用该类。 局部内部类可以使用外部类的成员，包括私有的。
• 局部内部类可以使用外部方法的局部变量，但是必须是final的。由局部内部类和局部变量的声明周期不同所致。
• 局部内部类和局部变量地位类似，不能使用public、protected、缺省、private。
• 局部内部类不能使用static修饰，因此也不能包含静态成员。

5、匿名内部类

匿名内部类不能定义任何静态成员、方法和类，只能创建匿名内部类的一 个实例。一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类。

new 父类构造器（实参列表）/实现接口(){ 
    //匿名内部类的类体部分 
}

匿名内部类的特点：

• 匿名内部类必须继承父类或实现接口
• 匿名内部类只能有一个对象
• 匿名内部类对象只能使用多态形式引用

interface Product{
	public double getPrice();
	public String getName();
}
public class AnonymousTest{
	public void test(Product p){
		System.out.println("购买了一个" + p.getName() + "，花掉了" + p.getPrice());
	}
	public static void main(String[] args) {
		AnonymousTest ta = new AnonymousTest();
		//调用test方法时，需要传入一个Product参数，
		//此处传入其匿名实现类的实例
		ta.test(new Product(){
			public double getPrice(){
				return 567.8;
			}
			public String getName(){
				return "AGP显卡";
			}
		});
	}
}

运行结果：

购买了一个AGP显卡，花掉了567.8