Java 4种内部类

静态内部类

/**
 * 静态内部类
 * 1.声明在类体部，方法体外，并且使用static修饰的内部类
 * 2.访问特点可以类比静态变量和静态方法
 * 3.脱离外部类的实例独立创建
 * 在外部类的外部构建内部类的实例
 * new Outer.Inner();
 * 在外部类的内部构建内部类的实例
 * new Inner();
 * 4.静态内部类体部可以直接访问外部类中所有的静态成员，包含私有
 * <p>
 * 用途：多用于单例模式
 */
public class StaticInnerTest {
    public static void main(String[] args) {
        System.out.println("test");
        StaticOuter.StaticInner.staticPrint(); //在使用内部类的时候才会进行加载
        new StaticOuter.StaticInner().print(); //实例化内部类时不需要实例化外部类
        new StaticOuter().print();
    }
}
class StaticOuter {
    private String s1 = "s1";
    private static String s2 = "s2";
    private static void sattic_print() {
        System.out.println("outer");
    }
    public void print() {
        //可以直接实例化
        StaticInner innerClass = new StaticInner();
        innerClass.print();
    }
    public static class StaticInner {
        static {
            System.out.println("inner class load");
        }
        public static void staticPrint() {
            StaticOuter.sattic_print();
        }
        public void print() {
            //System.out.println(s1);
            System.out.println(s2);
        }
    }
}

成员内部类

/**
 * 成员内部类
 * 1.没有使用static修饰的内部类。
 * 2.在成员内部类中不允许出现静态变量和静态方法的声明。
 * static只能用在静态常量的声明上。
 * 3.成员内部类中可以访问外部类中所有的成员(变量，方法)，
 * 包含私有成员，如果在内部类中定义有和外部类同名的实例变量，访问：OuterClass.this.outerMember;
 * 4.构建内部类的实例，要求必须外部类的实例先存在
 * 外部类的外部/外部类的静态方法：new Outer().new Inner();
 * 外部类的实例方法：
 * new Inner();
 * this.new Inner();
 * <p>
 * 应用场景：每一个外部类对象都需要一个内部类的实例，内部类离不开外部类存在
 * 应用例子：Netty中的Channel
 */
public class MemberInnerTest {
    public static void main(String[] args) {
        new MerberOuter().new MerberInner().print();
        new MerberInnerSon(new MerberOuter()).print();
    }
}

class MerberOuter {
    private String s1 = "outer s1";

    private void print() {
        System.out.println("outer print");
        System.out.println(new MerberInner());
    }
    class MerberInner {
        private final static String name = "Inner";
        //属性和方法不能加 static
        private /*static*/ String s1 = "inner s1";
        public  /*static*/ void print() {
            System.out.println("inner print");
            System.out.println(s1);
            // 调用与外部类相同名称的属性
            System.out.println(MerberOuter.this.s1);
            MerberOuter.this.print();
        }

    }
}
//继承时 空间名要写全，构造函数要加入外部类实例
class MerberInnerSon extends MerberOuter.MerberInner {
    public MerberInnerSon(MerberOuter outer) {
        outer.super();
    }
}

局部内部类

/**
 * 局部内部类
 * 1.定义在方法体，甚至比方法体更小的代码块中
 * 2.类比局部变量。
 * 3.局部内部类是所有内部类中最少使用的一种形式。
 * 4.局部内部类可以访问的外部类的成员根据所在方法体不同。
 * 如果在静态方法中：
 * 可以访问外部类中所有静态成员，包含私有
 * 如果在实例方法中：
 * 可以访问外部类中所有的成员，包含私有。
 * 局部内部类可以访问所在方法中定义的局部变量，但是要求局部变量不会被修改（通常使用final 关键字）。
 * 5.局部类内部类不能定义除了常量以外静态成员
 */

public class LocalInnerTest {

    public static void main(String[] args) {
        LocalOuter.test1();
        new LocalOuter().test2();
    }
}
class LocalOuter {
    private static String s1 = "outer static member";
    private String s3 = "outer member";

    public static void test1() {
        String s2 = "outer static fuction member";
        class LocalInner {
            private /*static*/ String s5 = "innner member";
            private /*static*/ void print() {
                System.out.println(s1);
                System.out.println(s2);
                System.out.println(s5);
            }
        }
        new LocalInner().print();
    }
    public void test2() {
        final String s2 = "outer fuction member";
        String s4 = "outer fuction member no final";
        class LocalInner {
            private /*static*/ String s5 = "innner member";
            private void print() {
                System.out.println(s1);
                System.out.println(s2);
                System.out.println(s3);
                System.out.println(s4);
                System.out.println(s5);
            }
        }
        new LocalInner().print();
    }
}

匿名类

/**
 * 匿名内部类
 * 即时定义即时使用。省代码啊！
 */
public class AnyInnerTest {
    public static void main(String[] args) {
        //实现两个匿名类，分别实现接口和继承抽象类。
        new Thread(new Runnable() {
            @Override
            public void run() {
                new AbstracAny("any") {
                    @Override
                    void say() {
                        System.out.println("my name : " + name);
                    }
                }.say();
            }
        }).start();
    }
}
abstract class AbstracAny {
    public String name;
    public AbstracAny(String name) {
        this.name = name;
    }
    abstract void say();
}