/**

 * 1,内部类一般只为其外部类使用;

 * 2,内部类提供了某种进入外部类的窗户;

 * 3,每个内部类都能独立的继承一个接口,而无论外部类是否已经继承了某个接口,因此内部类使得多重继承得以实现

 * @Author jisen

 * @Date 2019/3/5 14:30

 */

public class OutClass extends ClassB {

    //常量,类变量,普通变量

    private static final Object OUTREFERENCECONSTANT = new Object();//外部常量

    private static Object outStaticRefField = new Object();//外部类变量

    private Object outField = new Object();//外部普通变量

​

    //外部类方法

    public void outmethod(){}//外部普通方法

    public static void outstaticmethod(){}//外部静态方法

​

    //静态内部类可继承可实现

    static class InnerStaticClass extends ClassA implements ClassC{

        private static final Object INREFERENCECONSTANT2 = new Object();//静态内部类常量

        private static Object inStaticRefField = new Object();//静态内部类,类变量

        private Object inField = new Object();//静态内部类普通变量

​

        //静态内部类的静态方法只能访问静态内外成员

        public static void innerStaticClassMethod(){

            //outmethod();

            //innerClassMethod();

            outstaticmethod();

            innerStaticClassMethod();

            System.out.println(OUTREFERENCECONSTANT);

            System.out.println(INREFERENCECONSTANT2);

            System.out.println(outStaticRefField);

            System.out.println(inStaticRefField);

            //System.out.println(outField);

            //System.out.println(inField);

        }

        ////静态内部类的普通方法只能访问外部静态成员,以及内部所有成员

        public void innerClassMethod(){

            //outmethod();//静态方法不能访问外部非静态方法

            innerClassMethod();

            outstaticmethod();

            innerStaticClassMethod();

            System.out.println(OUTREFERENCECONSTANT);

            System.out.println(INREFERENCECONSTANT2);

            System.out.println(outStaticRefField);

            //System.out.println(outField);

            System.out.println(inField);

        }

    }

​

    //普通内部可继承可实现

    class InnerClass extends ClassA implements ClassC{

        private final Object INREFERENCECONSTANT3 = new Object();//可以定义不可变量

        //private static final Object INREFERENCECONSTANT4 = new Object();//无法定义常量

        //private static Object inStaticRefField2 = new Object();//不可定义类变量

        private Object inField2 = new Object();//可定义普通变量

        //普通内部类只能有普通方法,可访问外部类的所有成员

        public void innerMethod(){

            System.out.println(OUTREFERENCECONSTANT);

            System.out.println(outStaticRefField);

            System.out.println(outField);

        }

        //public static void innerMethod2(){}

    }

}

/**

 * @Desc 内部类的使用

 * @Author jisen

 * @Date 2019/3/5 14:34

 */

public class TestStatic {

    public void method(){

        //通过外部类对象所能到达的所有操作

        OutClass outClass = new OutClass();

        outClass.outmethod();

        OutClass.InnerClass innerClass = outClass.new InnerClass();

        innerClass.innerMethod();

​

        //通过外部类名所能达到的操作

        OutClass.outstaticmethod();//访问外部公共静态成员

        OutClass.InnerStaticClass.innerStaticClassMethod();//访问公共静态成员,再访问静态成员内部的静态成员

​

        //静态内部类对象,静态内部类可以不通过外部实例对象,直接new产生

        OutClass.InnerStaticClass innerStaticClass = new OutClass.InnerStaticClass();

        innerStaticClass.innerClassMethod();//用静态内部类实例对象访问成员

​

        //普通静态内部类,需要外部类的实例对象

        OutClass.InnerClass innerClass1 = new OutClass().new InnerClass();

        innerClass1.innerMethod();

    }

}

//饿汉式,静态常量,类加载的时候在准备阶段这个常量就分配了内存并赋值,

//始终只有一个实例,避免了线程安全问题

public class Singleton {

    private static final Singleton INSTANCE = new Singleton();

    private Singleton(){}

    public static Singleton getInstance(){

        return INSTANCE;

    }

}

//饿汉式静态代码块,原理跟静态常量一样,在类加载的准备阶段赋初值null,

//初始化阶段执行<client>(),实例化对象并赋值给静态成员

public class Singleton {

    private static Singleton instance;

    static {

        instance = new Singleton();

    }

    private Singleton(){}

    public static Singleton getInstance(){

        return instance;

    }

}

//静态内部类,本质上跟第一种是一样的,内部类常量,在类加载的准备阶段就实例化了.

//只有一份避免了线程竞争产生多分

public class Singleton {

    private Singleton() {}

    private static class SingletonInstance {

        private static final Singleton INSTANCE = new Singleton();

    }

​

    public static Singleton getInstance() {

        return SingletonInstance.INSTANCE;

    }

}