内部类

将内部类看作是一个类的成员

1.非静态内部类中不可以包含静态变量变量、方法以及静态块。非静态内部类可以访问外部类的实例成员和类成员。
2.接口也可以有内部接口

注意事项：（代码中）

public class TestInClass {

    private int out1=1;
    private static int out2=2;
    private int var =3;

    //  ###############################非静态内部类###################################
    public class InnerClass{
        private int var =33;
        //  编译错误，非静态内部类中不可以包含静态成员
        //private static int in1=11;

        {
            /**
             * 在非静态内部类中，可以引用外部类的静态、非静态成员，相反则不成立：
             *  因为内部类（静态、非静态）实例存在时，外部类实例必然存在，相反则不然，在实例化外部类实例时，
             *  不会自动实例化内部类。所以外部类不可直接访问内部类的成员
             */
            System.out.println("InnerClass area start");
            System.out.println(out1);
            System.out.println(out2);

            /**
             * 在内部类里面，当外部类与内部类有相同名称的变量时，有限使用内部类的
             */
            System.out.println("var= "+var);
            //  显示使用内部类的var
            System.out.println("InnerClass var is: "+this.var);
            //  显示使用外部内的var
            System.out.println("OuterClass var is:  "+TestInClass.this.var);
            System.out.println("InnerClass area end");
        }
        /**
         * 在非静态内部类中有一个队外部类的引用
         */
        public void infun(){
            System.out.println("infun..................");
            outfun1();
            outfun2();
        }
    }

    private void outfun1(){
        System.out.println("Outer class non static function");
    }
    private void outfun2(){
        System.out.println("Outer class static function");
    }

    //  在外部类内部创建内部类的实例
    public void createInstance(){
        InnerClass innerClass=new InnerClass();
        innerClass.infun();

        InnerStaticClass innerStaticClass=new InnerStaticClass();
        innerStaticClass.isfun();
    }

    //  main
    public static void main(String[] args) {
        //  下面编译错误：企图在静态方法中访问非静态成员（非静态内部类）
        //InnerClass innerClass=new InnerClass();
        InnerStaticClass innerStaticClass=new InnerStaticClass();

        TestInClass test=new TestInClass();
        test.createInstance();
    }


    //  #############################静态内部类#################################
    public static class InnerStaticClass{
        private int isin1=11;
        private static int isin2=22;
        public void isfun(){
            System.out.println("isfun()...................");
            /**
             * 静态内部类中，只能访问外部类的静态成员：静态成员不可以访问实例成员
             */
            //  System.out.println(out1);
            System.out.println(out2);
        }
    }
}

在外部类外部创建内部类对象：

package inClass.innerCLass;

/**
 * 在该内中去实例化静态内部类与非静态内部类
 */
public class TestNewInnerClass {
    public static void main(String[] args) {
        //############静态#############
        //  直接通过外部类.内部静态内部类名  创建
        TestInClass.InnerStaticClass innerStaticClass=new TestInClass.InnerStaticClass();
        innerStaticClass.isfun();

        System.out.println("------------------------");

        //############非静态#############
        //  非静态内部类的创建，必须已有一个外部类对象
        TestInClass testInClass=new TestInClass();
        TestInClass.InnerClass innerClass=testInClass.new InnerClass();
        innerClass.infun();
    }
}

匿名内部类：

1.当只需要使用一次 实现的接口或抽象的实现类时，可以考虑用匿名内部类。

package inClass.innerCLass;

interface Inter{
    void interfun();
}

public class NiMingInnerClass {
    public static void main(String[] args) {
        final int var=1;

        Inter inter=new Inter() {
            @Override
            public void interfun() {
                /**
                 * 匿名内部类中，可以访问外部的变量，单不允许修改
                 * java8之前只允许访问外部final修饰的变量
                 */
                System.out.println(var);
                //  var++;
                System.out.println("匿名内部类实现了接口方法");
            }
        };  //  必须带分号

        inter.interfun();
    }
}