Java内部类

将一个类的定义放在另一个类的内部，这就是内部类。

在面向对象语言中，任何一个类都可以在内部定义另外一个类，前者为外部类，后者为内部类。

内部类本身就是类的一个属性，与其他属性定义方式一致。内部类可以是静态和非静态的，它可以出现在属性定义、方法体和表达式中，甚至可以匿名出现，具体分为如下四种：

　　1、成员内部类：private class Xxx{}

　　2、局部内部类：定义在方法或表达式内部

　　3、匿名内部类：new Runnable(){}

　　4、静态内部类：static class Xxx{}

 

无论什么类型的内部类，都会编译成一个独立的.class 文件。

 

　　1、成员内部类

　　　　1、拥有内部类的类可以定义一个方法返回内部类的对象

　　　　2、内部类内部可以访问外部类的除了静态属性之外的所有属性包括私有属性和方法包括静态方法

　　　　3、内部类可以定义与外部类同名的属性和方法

　　　　4、外部类只能通过内部类的方式访问内部类的属性和方法

　　　　5、在外部类的外部创建内部类的对象则必须用外部类名.内部类名的方式 OutClass.InnerClass

　　　　6、成员内部类对象隐式地保存了一个引用，指向创建它的外部类对象。this

　　　　7、成员内部类不能有静态的属性和方法

public class NormalClass {
    private int i;
    private int h;

    public class InnerClass {
        private int i = 1;
        private int g=2;

        /**
         * 内部类可以访问外部类的私有属性等属性除了静态属性。
         *
         * @return
         */
        private int value() {
            return h;
        }

        /**
         * 可以访问外部类的方法
         */
        InnerClass ic = returnInner();
        int d = NormalClass.value();
    }

    /**
     * 外部类的方法可以创建内部类对象并返回
     *
     * @return
     */
    public InnerClass returnInner() {
        return new InnerClass();
    }

    private static int value() {
        return 1;
    }

    /**
     * 在外部类方法内可以向使用普通类一样
     * 但是在外部类中可以访问内部类的私有属性和私有方法
     */
    public void skip() {
        InnerClass inner = new InnerClass();
        int j = inner.i;
        j = inner.value();
        System.out.println(j);
    }

public static void main(String[] args) {
    NormalClass out = new NormalClass();
    InnerClass inner = out.new InnerClass();
}

}

　　

 

　　2、匿名内部类

　　　　new 类名|接口名(){

　　　　//

　　　　　　}

　　　　在匿名内部类的参数必须指定是final的。

 

 

 

　　3、静态内部类

　　　　1、静态内部类类似于一个静态属性

　　　　2、静态内部类可以访问外部类中的所有静态属性和方法

　　　　3、不能从静态内部类的对象中访问非静态的外部类属性和方法

　　　　4、创建静态内部类的对象，并不需要其外围类的对象

　　　　5、静态内部类的对象没有隐式地保存指向它的外部类的引用

　　　　6、可以通过 外部类.内部类的方式直接访问，而且其作用域不会扩散到包外

 　　

　　在JDK源码中，定义包内可见静态内部类的方式很常见，这样做的好处是：

　　　　1）作用域不会拓展到包外

　　　　2）可以通过 “外部类.内部类” 的方式直接访问

　　　　3）静态内部类可以访问外部类中的所有静态属性和静态方法

　　

public class StaticClass {
    private int i = 0;
    private static int j = 1;

    static class InnerClass {
        private static String str = "123";
        private int s;

        public void ask() {
            System.out.println(j);
            System.out.println(i);// 报错
            value();
            ert();// 报错
        }
    }

    public static String value() {
        return InnerClass.str;
    }

    /**
     * 外部类的普通方法可以访问静态内部类的属性
     *
     * @return
     */
    public String wer() {
        return InnerClass.str;
    }
    
    public String ert() {
        return "123";
    }

    public static void main(String[] args) {
        InnerClass inner = new InnerClass();
    }
}

 

　　为何要用内部类？

   　　1.   内部类一般只为其外部类使用；

  　　 2.   内部类提供了某种进入外部类的窗户；

   　　3.   也是最吸引人的原因，每个内部类都能独立地继承一个接口，而无论外部类是否已经继承了某个接口。因此，内部类使多重继承的解决方案变得更加完整。

 

END.