GroupBlog

内部类是在一个类的内部定义的类，内部类主要包括以下几种：

成员内部类
方法内部类
静态内部类
匿名内部类

其中匿名内部类又包括以下几种：

继承式匿名内部类
接口式匿名内部类
参数式匿名内部类

直接扔几个示例的代码，注释基本就够用了

首先看一下成员内部类，成员内部类的声明和使用如下：

package inner_class;

/**
 * Created by zhuxinquan on 16-7-21.
 */
public class InnerDemo1 {
    public static void main(String[] args) {
        Outer outer = new Outer("outer");

        //成员内部类通过外部实例化的对象来实例化内部类（一般不使用）
        Outer.Inner inner = outer.new Inner();
        System.out.println(inner.getName());

        System.out.println(outer.InnerGetName());
    }
}

class Outer{
    private String name;

    public Outer(String name) {
        this.name = name;
    }

    //成员内部类
    class Inner{
        public String getName(){
            return name;
        }
    }

    //在本类方法中直接声明内部类，可直接使用
    public String InnerGetName(){
        Inner inner = new Inner();
        return inner.getName();
    }
}

接着是方法内部类，示例如下：

package inner_class;

/**
 * Created by zhuxinquan on 16-7-21.
 */
public class MethodInnerClass {
    public static void main(String[] args) {
        Outer1 outer1 = new Outer1("name");
        System.out.println(outer1.getName());
    }
}

class Outer1{
    private String name;

    public Outer1(String name) {
        this.name = name;
    }

    //方法内部类
    //方法内部类只能在定义该内部类的方法内实例化，不可以在方法外对其实例化
    //方法内部类对象不能使用该内部类所在方法的非final局部变量
    public String getName(){
        //jdk1.8中当有方法内部类对象访问了所在方法的非final局部变量时，
        //该变量就会默认成为final变量，不可再次进行修改
        int x = 10;
        //内部类能独立的继承一个实现，使得多重继承的解决方案变得完整
        class Inner extends A{
            public String InnerGetName(){
                System.out.println(x);
                //非法的修改final变量
                //x = 20;
                return name;
            }
        }
        Inner inner = new Inner();
        return inner.InnerGetName();
    }
}

class A{
    public String  A;
}

静态内部类：

package inner_class;

/**
 * Created by zhuxinquan on 16-7-21.
 * 一个静态内部类相当于外部类
 */
public class StaticInnerClass {
    public static void main(String[] args) {
        //静态内部类的声明如下，静态内部类可以当做外部类使用
        Outer2.Inner inner = new Outer2.Inner();
        inner.InnerGetName();
    }
}

class Outer2{
    private String name;

    public Outer2(String name) {
        this.name = name;
    }

    static class Inner{
        public void InnerGetName(){
            System.out.println("Static Inner Class");
        }
    }
}

匿名内部类包括的3类（继承式、接口式、参数式的示例如下）：

package inner_class;

/**
 * Created by zhuxinquan on 16-7-21.
 * 匿名内部类：
 * 1.不能有构造方法，只能有一个实例（即刚产生的对象）
 * 2.不能定义任何静态成员，静态方法
 * 3.不能是public，protected，private，static
 * 4.在new的后面，用其隐含实现一个接口或实现一个类
 * 5.匿名内部类为局部的，所以局部内部类的所有限制都对其生效
 */
public class AnonymityInnerClass {
    public static void main(String[] args) {

        //继承式匿名内部类，继承匿名内部类中重写了say()方法
        Outer3 outer3 = new Outer3("name") {
            public void say() {
                System.out.println("继承式匿名内部类");
            }
        };
        outer3.say();

        //接口式匿名内部类，直接实现了接口
        Child child = new Child() {
            @Override
            public void talk() {
                System.out.println("接口式匿名内部类");
            }
        };
        child.talk();

        //参数式匿名内部类，将实现接口的类直接new一个新的对象之后当做参数传入
        childTalk(new Child() {
            @Override
            public void talk() {
                System.out.println("参数式匿名内部类");
            }
        });
    }

    public static void childTalk(Child c){
        c.talk();
    }
}

class Outer3{
    private String name;

    public Outer3(String name) {
        this.name = name;
    }

    public void say(){
        System.out.println("Outer3");
    }
}

interface Child{
    public void talk();
}