Java基础——内部类

一、什么是内部类

　　将一个类定义在另一个类里面或者一个方法里面，这样的类称为内部类

　　内部类所在的类在编译成功后，会出现这样两个class文件：OuterClass.class和OuterClass$InnerClass.class。

　　内部类主要分为四种：

　　　　成员内部类、局部内部类、匿名内部类、静态内部类

二、成员内部类

　　成员内部类，顾名思义它的身份是作为一个类的成员，我们来看它是怎么定义的

package com.jiangbei.test.innerclass;

/**
 * 外部类
 * 作者： Administrator
 * 日期： 2017/9/24
 **/
public class OutterClass {
    private String name;
    private Integer age;

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    // 内部类
    public class InnerClass{
        public InnerClass(){
            name = "张三";
            age = 18;
        }
        public void show(){
            System.out.println("i am InnerClass");
        }
        public void display(){
            System.out.println("name:"+getName()+" age:"+getAge());
        }
    }
    // 推荐使用getInnerClass()获取内部类
    public InnerClass getInnerClass(){
        // 当然也可以在外部类创建内部类引用，当内部类为空时新建，不为空时返回，实现单例的效果
        return new InnerClass();
    }

    public static void main(String[] args) {
        OutterClass outter = new OutterClass();
        // InnerClass inner = new InnerClass(); 无法直接创建内部类
        // OutterClass.InnerClass inner = outter.new InnerClass(); 不推荐
        OutterClass.InnerClass inner = outter.getInnerClass();
        inner.show();
        inner.display();
    }
}

　　结果：

　　

　　由此我们可以知道：

　　　　1.成员内部类依靠外部类，只有创建了外部类实例才能创建成员内部类

　　　  2..成员内部类可以无限制访问外部类成员，即使它是private的

　　　  3.外部类想访问成员内部类的方法和变量，必须通过内部类的实例

 三、局部内部类

　　嵌套在方法和作用域的，对于这个类的使用主要是应用与解决比较复杂的问题，想创建一个类来辅助我们的解决方案，到那时又不希望这个类是公共可用的，所以就产生了局部内部类。

　　引用海子(http://www.cnblogs.com/dolphin0520/)的实例：

class People{
    public People() {
         
    }
}
 
class Man{
    public Man(){
         
    }
     
    public People getWoman(){
        class Woman extends People{   //局部内部类
            int age =0;
        }
        return new Woman();
    }
}

 　　这里需要注意的是：

　　　　1.局部内部类类似一个局部变量，无法拥有访问修饰符！

四、匿名内部类

　　一般来说，匿名内部类用于继承其他类或是实现接口，并不需要增加额外的方法，只是对继承方法的实现或是重写。

new 父类构造器（形参列表） | 实现接口（）{

　　// 重写方法或实现方法
}

　　比较典型的就是swing中的事件绑定了：

button1.addActionListener(  
                new ActionListener(){  
                    public void actionPerformed(ActionEvent e) {  
                        System.out.println("你按了按钮二");  
                    }  
                });

　　　注意点：

　　　　1.匿名内部类必须是实现一个接口或者继承一个父类的方式

　　　　  2.匿名内部类没有构造函数

　　　　  3.匿名内部类不能存在静态变量静态方法

　　　　  4.匿名内部类不能是抽象的（继承抽象类、实现接口必须重写、实现所有方法）

　　　　  5.Java为了避免数据不同步的问题，做出了匿名内部类只可以访问final的局部变量的限制。

　　　　　　关于这点通俗的解释，请参见：http://www.jianshu.com/p/609ca1c584ac

　　　更多匿名内部类的详解，参见：http://www.cnblogs.com/chenssy/p/3390871.html

五、静态内部类

　　和成员变量类似，不过它是静态的，不再需要依靠外部类

  /**
     *静态内部类
     */
    static class InnerClass1{
        /* 在静态内部类中可以存在静态成员 */
        public static String _name1 = "chenssy_static";
        
        public void display(){
            /* 
             * 静态内部类只能访问外围类的静态成员变量和方法
             * 不能访问外围类的非静态成员变量和方法
             */
            System.out.println("OutClass name :" + name);
        }
    }

　　更多有关内部类的讲解与深入，请参见：http://www.cnblogs.com/dolphin0520/p/3811445.html

　　　　　　　　　　　　　　　　　　　　http://www.cnblogs.com/chenssy/p/3388487.html