内部类（转）

  内部类（Inner class）

         将相关的类组织在一起，从而降低了命名空间的混乱。

          一个内部类可以定义在另一个类里，也可以定义在函数里，甚至可以作为一个表达式的一部分。

          内部类中不能定义静态成员。（静态成员不是对象的特征，只是为了找一个容身之所，所以需要放到一个类中而已，无需放到内部类中）

          java中的内部类分为四种：

            静态内部类static inner class（static nested class）

           成员内部类member inner class

           局部内部类local  inner  class

           匿名内部类 anonymous inner class

    静态内部类static inner class

         最简单的内部类形式。

         定义时加上static关键字

         不能和外部类有相同的名字

         被编译成一个完全独立的 .class文件，名称为OuterClass$InnerClass.class的形式。

         只可以访问外部类的静态成员和静态方法，包括私有静态成员和方法。

         生成静态内部类对象的方式为：

         OuterClass.InnerClass inner=new OuterClass.InnerClass();

静态内部类使用测试

package com.learnjava.innerclass;

class StaticInner
{
    private static int a = 4;

    // 静态内部类
    public static class Inner
    {
        public void test()
        {
            // 静态内部类可以访问外部类的静态成员
            // 并且它只能访问静态的
            System.out.println(a);
        }

    }
}

public class StaticInnerClassTest
{

    public static void main(String[] args)
    {
        StaticInner.Inner inner = new StaticInner.Inner();
        inner.test();
    }
}

    成员内部类member inner class

         成员内部类也是定义在另一个类中，但是定义时不用static修饰。

         成员内部类和静态内部类可以类比为非静态的成员变量和静态的成员变量。

         成员内部类就像一个实例变量。

         它可以访问它的外部类的所有成员变量和方法，不管是静态的还是非静态的都可以。

         在外部类里面创建成员内部类的实例：

         this.new  InnerClass();

         在外部类之外创建内部类的实例：

         (new OuterClass()).new  InnerClass();

         在内部类里访问外部类的成员：

         OuterClass.this.member

成员内部类使用测试

package com.learnjava.innerclass;

class MemberInner
{
    private int d = 1;
    private int a = 2;

    // 定义一个成员内部类
    public class Inner2
    {
        private int a = 8;

        public void doSomething()
        {
            // 直接访问外部类对象
            System.out.println(d);
            System.out.println(a);// 直接访问a，则访问的是内部类里的a

            // 如何访问到外部类里的a呢？
            System.out.println(MemberInner.this.a);
        }

    }

}

public class MemberInnerClassTest
{

    public static void main(String[] args)
    {

        // 创建成员内部类的对象
        // 需要先创建外部类的实例
        MemberInner.Inner2 inner = new MemberInner().new Inner2();

        inner.doSomething();
    }
}

    局部内部类Local  Inner  Class

         局部内部类定义在方法中，比方法的范围还小。是内部类中最少用到的一种类型。

         像局部变量一样，不能被public，protected，private和static修饰。

         只能访问方法定义中的final类型的局部变量。

         局部内部类在方法中定义，所以只能在方法中使用，即只能在方法当中生成局部内部类的实例并且调用其方法。

局部内部类使用测试

package com.learnjava.innerclass;

class LocalInner
{
    int a = 1;

    public void doSomething()
    {
        int b = 2;
        final int c = 3;
        // 定义一个局部内部类
        class Inner3
        {
            public void test()
            {
                System.out.println("Hello World");
                System.out.println(a);

                // 不可以访问非final的局部变量
                // error: Cannot refer to a non-final variable b inside an inner
                // class defined in a different method
                // System.out.println(b);

                // 可以访问final变量
                System.out.println(c);
            }
        }

        // 创建局部内部类的实例并调用方法
        new Inner3().test();
    }
}

public class LocalInnerClassTest
{
    public static void main(String[] args)
    {
        // 创建外部类对象
        LocalInner inner = new LocalInner();
        // 调用外部类的方法
        inner.doSomething();
    }

}

    匿名内部类Anonymous Inner Class

         匿名内部类就是没有名字的局部内部类，不使用关键字class，extends，implements,没有构造方法。

         匿名内部类隐式地继承了一个父类或者实现了一个接口。

         匿名内部类使用的比较多，通常是作为一个方法参数。

匿名内部类使用测试

package com.learnjava.innerclass;

import java.util.Date;

public class AnonymouseInnerClass
{

    @SuppressWarnings("deprecation")
    public String getDate(Date date)
    {
        return date.toLocaleString();

    }

    public static void main(String[] args)
    {
        AnonymouseInnerClass test = new AnonymouseInnerClass();

        // 打印日期：
        String str = test.getDate(new Date());
        System.out.println(str);
        System.out.println("----------------");

        // 使用匿名内部类
        String str2 = test.getDate(new Date()
        {
        });// 使用了花括号，但是不填入内容，执行结果和上面的完全一致
            // 生成了一个继承了Date类的子类的对象
        System.out.println(str2);
        System.out.println("----------------");

        // 使用匿名内部类，并且重写父类中的方法
        String str3 = test.getDate(new Date()
        {

            // 重写父类中的方法
            @Override
            @Deprecated
            public String toLocaleString()
            {
                return "Hello: " + super.toLocaleString();
            }

        });

        System.out.println(str3);
    }
}

        生成的 .class文件中，匿名内部类会生成OuterClass$1.class文件，数字根据是第几个匿名内部类而类推。