（4）JavaSE---内部类

public class TestOut1 {

    private String sayHello = "Hello, I am TestOut1 !";
    private String outStr = "I am TestOut1 ! ";
    private static int outStaticVar = 1;

    /**
     * 成员方法
     * */
    public void outMethod() {
        System.out.println("I am TestOut1 Method");
    }
    /**
     * 静态方法
     */
    public static void outerStaticMethod(){
        System.out.println("I am TestOut1 static Method");
    }

    /**
     * 内部类  Inner
     * 该内部类 可以按照 外部类成员 进行理解
     *      必须先创建外部类实例对象，才可以调用 该对象成员
     *      因此： 需先创建对象实例： TestOut1  out = new TestOut1();
     *          才能创建内部类对象： TestOut1.InnerTest1 inner = out.new InnerTest1();
     *
     *      类似方法：
     *      TestOut1.InnerTest1 inner = out .new InnerTest1();
     *      TestOut1.InnerTest1 inner1 = new TestOut1().getInnerInstance();
     *
     * */
    class InnerTest1 {
        private String sayHello = "Hello, I am InnerTest1 !";
        private String innerStr = "I am InnerTest1";


        /**
         * 内部类成员方法，访问外部类信息
         * */

        public void innerShow() {
            /** --- 就近原则 ---
             * 内部类含有与外部类 含有同名 成员 方法/变量 ， 直接引用属性名，是内部类成员变量
             * 内部类访问外部类同名属性， 外部类.this.属性名
             * */
            System.out.println("InnerTest1--- sayHello: " + sayHello);

            System.out.println("OutTest1--- sayHello: " + TestOut1.this.sayHello);

            // 访问外部方法
            outMethod();;
            outerStaticMethod();
        }

    }

    /**
     * 外部类访问内部类信息*/
    public void outShow(){
        InnerTest1 inner = new InnerTest1();
        inner.innerShow();
    }

    /**
     * TestOut1 定义get方法，获取InnerTest1 对象
     * 外部调用时，只需要调用 out.getInnerInstance()
     * */
    public InnerTest1 getInnerInstance(){
        return new InnerTest1();
    }
}

public class TestOut2 {

    private String sayHello = "Hello, I am TestOut2 !";
    private String outStr = "I am TestOut2 ! ";
    private static int outStaticVar = 2;

    /**
     *  静态块执行
     * */
    static {
        System.out.println("Outer 静态块执行");
    }

    /**
     * 成员方法
     * */
    public void outMethod() {
        System.out.println("I am TestOut1 Method");
    }
    /**
     * 静态方法
     */
    public static void outerStaticMethod(){
        System.out.println("I am TestOut1 static Method");
    }

    /**
     * 内部类  static Inner
     * 该内部类 可以按照 外部类成员 进行理解
     *      访问类的静态成员，可以不用 创建实例对象  通过 类名.成员 访问  TestOut2.InnerTest2()
     *      因此： ： TestOut2.InnerTest2  inner = new TestOut2.InnerTest2();
     *          才能创建内部类对象： TestOut1.InnerTest1 inner = out.new InnerTest1();
     *
     *      类似方法：
     *      TestOut1.InnerTest1 inner = out .new InnerTest1();
     *      TestOut1.InnerTest1 inner1 = new TestOut1().getInnerInstance();
     *
     * */
    public static class InnerTest2 {
        private String sayHello = "Hello, I am InnerTest1 !";
        private String innerStr = "I am InnerTest1";


        static {
            System.out.println(" InnerTest2 静态块执行！");
        }
        /**
         * 内部类非成员方法，访问外部类信息
         * 1、访问外部 非静态成员  --- 静态类内部只能访问外部的 静态成员，对于非静态成成员不能访问，
         *                         因为静态内部类编译完不隐含外部类的引用，与内部类内部是否是静态成员无关
         * 2、访问外部 静态成员   --- 可以访问
         * */

        public  void innerShow() {
            /** --- 就近原则 ---
             * 内部类含有与外部类 含有同名 成员 方法/变量 ， 直接引用属性名，是内部类成员变量
             * 内部类访问外部类同名属性，
             * */;
            // System.out.println("OutTest1--- " + TestOut2.this.sayHello); // 报错
            System.out.println("InnerTest1--- sayHello: " + sayHello);
            System.out.println("OutTest1--- outStaticVar: " + TestOut2.outStaticVar);


            // 访问外部方法
            //outMethod();
            outerStaticMethod();
        }

        /**
         * 内部类静态成员，访问外部成员
         *     因为静态内部类编译完不隐含外部类的引用，与内部类内部是否是静态成员无关
         * 1、访问外部 非静态成员  --- 报错
         * 2、访问外部 静态成员   ---- ture
         * */
        public  static void innerStaticShow() {
            //System.out.println("OutTest1--- outStaticVar: " + TestOut2.this.sayHello);//报错
            System.out.println("OutTest1--- outStaticVar: "+ TestOut2.outStaticVar);
        }


    }

    /**
     * 外部类访问内部类信息*/
    public void outShow(){
        TestOut2.InnerTest2 inner = new TestOut2.InnerTest2();
        inner.innerShow();
        // inner.sayHello;

    }

    /**
     * TestOut1 定义get方法，获取InnerTest1 对象
     * 外部调用时，只需要调用 out.getInnerInstance()
     * */
    public TestOut2.InnerTest2 getInnerInstance(){
        return new TestOut2.InnerTest2();
    }


}

public class FuncOutter {
    private String sayHello = "hello, I am FuncOutter!";
    private String funcOutter = "I am Function!";
    private static String funcStaticOutter = "I am static Outter";
    public void display(int temp){

        String funcVar = "I am display func";
        /**
         * 方法内部类
         * 1、 不能被权限修饰符修饰
         * 2、 */
        class Inner{
            private  String sayHello = "hello, I am Inner";
            private  String funcInner = "I am Inner";
            /**
             * 方法内部类，不能创建 静态变量,函数
             * */
            //private static  String funcStaticInner = "I am static Inner"; //报错

            /**
             * 方法内部类： 成员函数
             * 1、访问自身成员
             * 2、访问外部类成员( 非静态/静态/)
             * 3、访问方法参数
             * 4、访问方法内局部变量
             * */
            public void innerShow(){
                System.out.println("Inner sayhello: " + sayHello);
                System.out.println("Outteer sayHell: " + FuncOutter.this.sayHello);
                /***访问方法内的局部变量和参数需要有
                * 1、直接被final修饰的变量
                * 2、已被赋值且始终未改变的变量(有且仅赋值一次)，引用指向不能改变
                *  JDK8以前(不包括8)， 只能访问被final 修饰的变量。
                 * */
                System.out.println("display 参数： " + temp);
                System.out.println("display 局部变量" + funcVar);

            }
        }
        // 局部内部类只能在方法内使用
        Inner inner = new Inner();
        inner.innerShow();
    }

}