Java中的内部类

内部类的分类

内部类的特点

1. 可以使用private、protected修饰。也可以使用abstract、final等修饰.
2. 内部类可以直接或利用引用访问外部类的属性和方法，包括私有属性和方法（但静态内部类不能访问外部类的非静态成员变量和方法）。内部类所访问的外部属性的值由构造时的外部类对象决定.
3. 外部类要访问内部类的成员，则只能通过引用的方式进行，可问内部类所有成员
4. 内部类可以继承同级的内部类，也可继承其它类（除内部类和外部类）
5. 内部类可以定义为接口，并且可以定义另外一个类来实现它
6. 内部类可以定义为抽象类，可以定义另外一个内部类继承它
7. 方法内的内部类不能加范围限定(protected public private),方法内的内部类不能加static修饰符,方法内的内部类只能在方法内构建其实,方法内的内部类如果访问方法局部变量，则此局部变量必须使用final修饰

静态内部类

测试代码I

/**
 * 类定义时加上static关键字。
 * 不能和外部类有相同的名字。
 * 被编译成一个完全独立的.class文件，名称为OuterClass$InnerClass.class的形式。
 * 只可以访问外部类的静态成员和静态方法，包括了私有的静态成员和方法。
 * 生成静态内部类对象的方式为：
 * OuterClass.InnerClass inner = new OuterClass.InnerClass();
 */

public class StaticInnerClassTest {
    private static String string = "Hello World";
    /**
     * 静态内部类可以访问外部类的静态成员
     * 并且它只能访问静态的
     */
    private static class StaticInnerClass{
        public void test(){
            System.out.println(string);
        }
    }
    public static void main(String[] args){
        /**
         * 无论定义的是private还是public，都可以在外部类使用
         */
        StaticInnerClass staticInnerClass = new StaticInnerClass();
        staticInnerClass.test();
    }
}

测试代码II

class OuterClass {
    private static String string = "Hello World";

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

public class StaticInnerClassTest2 {
    public static void main(String[] args) {
        /**
         * 当内部类是public,protected或者default时，可以在外部定义,
         * private声明的静态内部类，不能在外面访问.
         */
        OuterClass.StaticInnerClass staticInnerClass = new OuterClass.StaticInnerClass();
        staticInnerClass.test();
    }
}

成员内部类

测试代码

/**
 * 成员内部类也是定义在另一个类中，但是定义时不用static修饰。
 * 成员内部类和静态内部类可以类比为非静态的成员变量和静态的成员变量。
 * 成员内部类就像一个实例变量。
 * 它可以访问它的外部类的所有成员变量和方法，不管是静态的还是非静态的都可以。
 */

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

    public class MemberInnerClass {
        private int a = 8;

        public void doSomething() {
            System.out.println(d);
            /**
             * 直接访问a，则访问的是内部类里的a
             */
            System.out.println(a);
            /**
             如何访问到外部类里的a呢？
             */
            System.out.println(MemberInner.this.a);
        }
    }
}

public class MemberInnerClassTest {

    public static void main(String[] args) {
        /**
         *创建成员内部类的对象
         * 需要先创建外部类的实例
         */
        MemberInner.MemberInnerClass memberInnerClassTest = new MemberInner().new MemberInnerClass();
        memberInnerClassTest.doSomething();
    }
}

匿名内部类

测试代码

import java.util.Date;

/**
 * 匿名内部类就是没有名字的局部内部类，不使用关键字class, extends, implements, 没有构造方法。
 * 匿名内部类隐式地继承了一个父类或者实现了一个接口。
 * 匿名内部类使用得比较多，通常是作为一个方法参数。
 */
public class AnonymousInnerClassTest {

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

    public static void main(String[] args) {
        AnonymousInnerClassTest test = new AnonymousInnerClassTest();
        String str = test.getDate(new Date());
        System.out.println(str);

        /**
         * 使用匿名内部类
         * 使用了花括号，但是不填入内容，执行结果和上面的完全一致
         * 生成了一个继承了Date类的子类的对象
         */

        String str2 = test.getDate(new Date() {
        });
        System.out.println(str2);

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

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

局部内部类

测试代码

/**
 * 局部内部类定义在方法中，比方法的范围还小。是内部类中最少用到的一种类型。
 * 像局部变量一样，不能被public, protected, private和static修饰。
 * 只能访问方法中定义的final类型的局部变量。
 * 局部内部类在方法中定义，所以只能在方法中使用，即只能在方法当中生成局部内部类的实例并且调用其方法。
 */
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的局部变量,只能访问final变量
                 */
                System.out.println(c);
            }
        }

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

public class LocalInnerClassTest {
    public static void main(String[] args) {
        LocalInner inner = new LocalInner();
        inner.doSomething();
    }
}