内部类

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

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

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

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

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

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

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();
}

内部类的使用间接的解决了JAVA中单继承的不足，因为一个方法内部类可以单独的继承一个其它类，而本方法中的方法内部类可以访问本类中的所有成员和方法，并且内部类在继承了其它类之后又可以访问其它类的成员属性和方法，因而在一定程度上解决了单继承的问题，但是也破坏了类的结构（属性和方法）。