java —— 内部类

_

普通内部类

　　静态内部类

　　局部内部类

　　匿名内部类

内部类

　　内部类是定义在另一个类中的类，定义内部类会起到的作用有以下三点：

　　 1、内部类方法访问该类定义所在的作用域中的数据，包括私有的数据。

　　 2、内部类可以对同一个包中的其他类隐藏起来

　　3、当想定义一个回调函数且不想写大量代码，使用匿名（anonymous）内部类会更加便捷。

　　下面用简单的内部类例子说明内部类的使用方式。

class OuterClass {
    private int outId = 0;
    private String outName = "out";
    public void outerShow() {
        System.out.println("OuterClass");
        System.out.println(outId + ":" + outName);
    }

    public class InnerClass {
        private String inName="inner";
        public void InnerShow() {
            System.out.println("InnerClass");
            System.out.println(outName + ":"+ this.inName);
        }
    }
}
public class InnerClassDemo {
    public static void main(String[] args) {
        OuterClass out = new OuterClass();
        OuterClass.InnerClass in = out. new InnerClass ();
        in.InnerShow();
    }
}

　　通过代码可以发现，

　　 1、内部类也可以用访问修饰进行控制（private public protected）

　　2、若内部类的是公开的 (public) ，可以直接在其它地方创建该类的实例。前提是该内部类的外部类的对象必须已经存在。代码如下：OuterClass.InnerClass in = out. new InnerClass ();

　　3、内部类也可以使用 this 进行属性调用

　　4、内部类既可以访问自己的数据域，也可以访问创建它的外围类对象的数据域。

　　这是因为，内部类的对象总有一个隐式引用，指向它的外部类对象。如图：

　　这个引用在内部类的定义中是不可见的,现在我们将外围类对象的引用称为 outer。于是 InnerShow 方法将等价干下列形式形式：

public void InnerShow() {

System.out.println("InnerClass");
System.out.println(outer.outName + ":"+ outer.inName);
}

　　外部类的引用在构造器中设置。编译器修改了所有的内部类的构造器，添加一个外部类引用的参数。因为 InnerClass 类没有定义构造器，所以编译器为这个类生成了一个默认的构造器，其代码如下所示：　

public InnerClass(OuterClass out){

　　outer=out 
}

　　备注：outer 不是Java 的关键宇。只是用它说明内部类中的机制。

内部类的特殊语法规则

　　在上面，已经讲述了内部类有一个外部类的引用 outer。事实上，使用外部类引用的正规语法还要复杂一些。

　　表达式 ：   OuterClass.this.  ——表示外部类引用。

　　例如，可以像下面这样编写 InnerClass 内部类的 InnerShow 方法 　

public void InnerShow() {
       System.out.println("InnerClass");
       System.out.println(OuterClass.this.outName + ":"+ OuterClass.this.inName);
}

　　 通常 this 限定词是多余的。不过，可以通过这种方式区分内部类与外部类属性名相同情况时，内部类的调用问题。

　　 重点：内部类中声明的静态属性必须是 final。原因很简单，我们希望一个静态域只有一个实例，不过对于每个外部对像，会分别有一个单独的内部类实例。如果这个不是 final ，它可能就不是唯一的。

　　内部类不可以定义 static 方法。

静态内部类

　　关键字 static 中提到 static 可以修饰成员变量、方法、代码块，其他它还可以修饰内部类，使用static修饰的内部类我们称之为静态内部类，也称之为嵌套内部类。

　　静态内部类与非静态内部类之间存在一个最大的区别，我们知道非静态内部类在编译完成之后会隐含地保存着一个引用，该引用是指向创建它的外围内，但是静态内部类却没有。没有这个引用就意味着：

　　 1、 它的创建是不需要依赖于外围类的。

　　 2、 它不能使用任何外围类的非static成员变量和方法。

局部内部类

　　局部类不能用 public 或 private 访问说明符进行声明，它的作用域被限定在声明这个局部类的块中。

　　局部类有一个优势，即对外部世界可以完全地隐藏起来。即使 OuterClass 类中的其他代码也不能访问它。除 outShow 方法外没有任何方法知道 AnonymousClass 类的存在。　

public void outerShow() {
        System.out.println("OuterClass");
        System.out.println(outId + ":" + outName);
        int age=123;
        class AnonymousClass{
            private void show(){
                System.out.println(age);
            }
        }
        new AnonymousClass().show();
    }

匿名内部类

　　匿名内部类的常用方式，实现函数的回调。

public abstract class Bird {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public abstract int fly();
}

public class Test {

    public void test(Bird bird){
        System.out.println(bird.getName() + "能够飞 " + bird.fly() + "米");
    }

    public static void main(String[] args) {
        Test test = new Test();
        test.test(new Bird() {

            public int fly() {
                return 10000;
            }

            public String getName() {
                return "大雁";
            }
        });
    }
}
------------------
Output：
大雁能够飞 10000米

　　在使用匿名内部类的过程中，我们需要注意如下几点： 　　

　　1、使用匿名内部类时，我们必须是继承一个类或者实现一个接口，但是两者不可兼得，同时也只能继承一个类或者实现一个接口。

　　2、匿名内部类中是不能定义构造函数的。

　　3、匿名内部类中不能存在任何的静态成员变量和静态方法。

　　4、匿名内部类为局部内部类，所以局部内部类的所有限制同样对匿名内部类生效。

　　5、匿名内部类不能是抽象的，它必须要实现继承的类或者实现的接口的所有抽象方法。

匿名内部类初始化

　　经常使用构造器来完成某个实例的初始化工作的，但是匿名内部类是没有构造器的！对此，我们可以使用构造代码块进行初始化工作。 演示代码如下：　

interface InnerClass{
    public String getName();

    public int getAge();
}
public class OuterClass {
    //java 8之前需要   final int age,final String name
    public InnerClass getInnerClass(int age,String name){
        return new InnerClass() {
            int age_ ;
            String name_;
            //构造代码块完成初始化工作
            {
                if(0 < age && age < 200){
                    age_ = age;
                    name_ = name;
                }

            }
            public String getName() {
                return name_;
            }

            public int getAge() {
                return age_;
            }
        };
    }

    public static void main(String[] args) {
        OuterClass out = new OuterClass();
        InnerClass inner_1 = out.getInnerClass(201, "chenssy");
        System.out.println(inner_1.getName());
        InnerClass inner_2 = out.getInnerClass(23, "chenssy");
        System.out.println(inner_2.getName());
    }
}

　　

　　备注：在Java SE 8 之前，必须把局部类和匿名内部类访问的局部变量声明为 final 。