Java中的内部类

内部类：

内部类共有四种分别为：静态内部类、成员内部类、局部内部类、匿名内部类。

1. 静态内部类

特点为：
1）定义在外部类中，方法外，并使用static修饰的内部类
2）访问静态内部类时与访问静态变量和静态方法相同
3）脱离外部类的实例独立创建
在外部类的外部创建内部类的实例格式
new Outer.Inner();
在外部类的内部创建内部类的实例格式
new Inner();
4）静态内部类内可以直接访问外部类中所有的静态成员，包括私有

public class Test {
    public static void main(String[] args) {
        StaticOuter.StaticInner.test();
        StaticOuter.StaticInner s = new StaticOuter.StaticInner();
        s.test2();
        System.out.println("StaticInner.a  = "+s.a);
        System.out.println("StaticInner.b  = "+s.b);
        //  System.out.println("StaticOuter.b  = "+StaticOuter.b);  这里报错
    }

}

class StaticOuter {
    private int a = 100;
    private static int b = 200;
    public static void test(){
        System.out.println("Outer static test ...");
    }
    public  void test2(){
        System.out.println("Outer instabce test ...");
    }   

    static class StaticInner {
        public int a = 300;
        static int b =400;
        public static void test(){
            System.out.println("Inner static test ...");
        }
        public  void test2(){
            System.out.println("Inner instance test ...");
            StaticOuter.test();
            new StaticOuter().test2();
            System.out.println("StaticOuter.a  = "+new StaticOuter().a);
            System.out.println("StaticOuter.b  = "+StaticOuter.b);
        }   
    }
}

运行结果：

Inner static test ...
Inner instance test ...
Outer static test ...
Outer instabce test ...
StaticOuter.a  = 100
StaticOuter.b  = 200
StaticInner.a  = 300
StaticInner.b  = 400

2.成员内部类(实例内部类)

特点为：
1）定义在在外部类中，方法外，没有使用static修饰的内部类。
2）在成员内部类中不允许出现静态变量和静态方法的声明，static只能用于静态常量的声明。
3）成员内部类中可以访问外部类中所有的成员(变量，方法)，包括私有，如果在内部类中定义有和外部类同名的实例变量，访问格式为：
OuterClass.this.outerMember;
4）创建内部类的实例，要求必须外部类的实例先存在
外部类的外部/外部类的静态方法：new Outer().new Inner();
外部类的实例方法：
new Inner();
this.new Inner();

class MemberOuter{

    private String s1 = "Outer InstanceMar";
    private String s2 = "OuterStatic s2";
    public void setS1(String s1) {
        this.s1 = s1;
        new MemberOuter().new MemberInner();
        this.new MemberInner();  //此时MemberOuter已经实例化完成,所以可以使用this
        new MemberInner().test2();
    }
    public static void  test2 (){
        new MemberOuter().new MemberInner();
        /*this.new MemberInner();  
         * 此时MemberOuter没有实例化完成,所以不可以使用this
         * static 是在MemberOuter构造器前使用,所以此时this不能使用
         * 
*/

    }


    class MemberInner{
         String s1= "Inner  instanceMar  ";
        static final String s4 = "static final  MemberInner";

                void test2(){
                    System.out.println(" s1 =" + s1);
                    System.out.println(" Outter MemberOuter.this.s1 =" + MemberOuter.this.s1);
                    System.out.println("s2 = "+s2);
                }
    }

}

public class Test5 {

    public static void main (String args []){
        MemberOuter.MemberInner mm =  new MemberOuter().new MemberInner();
        mm.test2();

        MemberOuter mo = new MemberOuter();
        mo.setS1("sqq");
    }
}

运行结果为：

s1 =Inner  instanceMar  
 Outter MemberOuter.this.s1 =Outer InstanceMar
s2 = OuterStatic s2
 s1 =Inner  instanceMar  
 Outter MemberOuter.this.s1 =sqq
s2 = OuterStatic s2

3.局部内部类

特点为：
1）定义在外部类中，方法内，甚至比方法体更小的代码块中
2）局部内部类与局部变量相同
3）局部内部类是所有内部类中使用最少的一种形式
4）局部内部类可以访问的外部类的成员根据所在方法体不同
如果在静态方法中：
可以访问外部类中所有静态成员，包括私有
如果在实例方法中：
可以访问外部类中所有的成员，包括私有

tips：局部内部类可以访问所在方法中定义的局部变量，但是要求局部变量必须使用final修饰。

public class Test6 {

    private int a = 1;
    private static int b = 2;

    public void test() {
        final int c = 3;
        class LocalInner {
            public void add1() {
                System.out.println("a= " + a);
                System.out.println("b= " + b);
                System.out.println("c= " + c);
            }
        }
        new LocalInner().add1();
    }

    static public void test2() {
        final int d = 5;
        class LocalInner2 {
            public void add1() {
                //System.out.println("a= " + a);
                System.out.println("b= " + b);
                System.out.println("c= " + d);
            }
        }
        new LocalInner2().add1();
    }

    public static void main(String args[]) {

        // LocalInnerTest() lc = new LocalInnerTest();
        new Test6().test();
        new Test6().test2();
    }
}

运行结果为：

a= 1
b= 2
c= 3
b= 2
c= 5

4.匿名内部类

特点为：
1）没有名字的只使用一次的局部内部类。
2）没有class,interface,implements,extends关键字
3）没有构造器。
4）一般隐式的继承某一个父类或者实现某一个接口

interface Pen {
    public void write();
}

class  Pencil implements Pen {
    @Override
    public void write() {
        //铅笔 的工厂
    }
}

class Person0 {
    public void user(Pen pen) {
        pen.write();
    }
}

public class Test7 {
    public static void main(String args[]) {
        Person0 guo = new Person0();

        guo.user(new Pen() {
            @Override
            public void write() {
                System.out.println("写字");
            }
        });
    }

}

运行结果为：

写字