package com.stulzl.member_innerclass01;

//成员内部类419-420
public class Member_InnerClass01 {
    public static void main(String[] args) {
        Outer08 outer08 = new Outer08();
        outer08.t1();

        //外部其他类访---成员内部类，外部其他类，使用成员内部类的两种方式
        //解读
        //第一种方式
        // outer08.new Inner08(); 相当于把 new Inner08()当做是 outer08 成员
        // 这就是一个语法，不要特别的纠结
        Outer08.Inner08 inner08 = outer08.new Inner08();
        inner08.say();

        // 第二方式 在外部类中，编写一个方法，可以返回 Inner08 对象
        Outer08.Inner08 inner08Instance = outer08.getInner08Instance();
        inner08Instance.say();

    }
}

class Outer08 { //外部类
    private int n1 = 10;
    public String name = "张三";

    private void hi() {
        System.out.println("hi()方法...");
    }

    //1.注意: 成员内部类，是定义在外部内的成员位置上
    //2.可以添加任意访问修饰符(public、protected 、默认、private),因为它的地位就是一个成员
    public class Inner08 {//成员内部类(因为它没卸载方法或者代码块中)
        private double sal = 99.8;
        private int n1 = 66;

        public void say() {
            //可以直接访问外部类的所有成员，包含私有的
            //成员内部类-访--- >外部类成员(比如:属性)访问方式:直接访问
            //如果成员内部类的成员和外部类的成员重名，会遵守就近原则.
            // ，可以通过 外部类名.this.属性 来访问外部类的成员
            System.out.println("n1 = " + n1 + " name = " + name
                    + " 外部类的 n1=" + Outer08.this.n1);
            hi();
        }
    }

    //写一个方法,调用成员内部类
    //外部类-- -----成员内部类(说明)访问方式创建对象，再访问
    public void t1(){
        //使用成员内部类
        //创建成员内部类的对象，然后使用相关的方法
        Inner08 inner08 = new Inner08();
        inner08.say();
        System.out.println(inner08.sal);
    }

    //方法，返回一个 Inner08 实例
    public Inner08 getInner08Instance(){
        return new Inner08();
    }
}

package com.stulzl.static_innerclass01;

//静态内部类421-422
public class Static_InnerClass01 {
    public static void main(String[] args) {
        Outer10 outer10 = new Outer10();
        outer10.m1();

        //外部其他类---访向---->静态内部类 外部其他类 使用静态内部类
        //方式 1
        //因为静态内部类，是可以通过类名直接访问(前提是满足访问权限)
        Outer10.Inner10 inner10 = new Outer10.Inner10();
        inner10.say();

        //方式 2
        //编写一个方法，可以返回静态内部类的对象实例
        Outer10.Inner10 inner = outer10.getInner();
        inner.say();

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

        //静态的
        Outer10.Inner10 inner_ = Outer10.getInner_();
        inner_.say();
    }
}
class Outer10 { //外部类
    private int n1 = 10;
    private static String name = "张三";//静态的
    private static void cry(){}
    //Inner10 就是静态内部类
    //1. 放在外部类的成员位置
    //2. 使用 static 修饰
    //4. 可以添加任意访问修饰符(public、protected 、默认、private),因为它的地位就是一个成员
    //5. 作用域 ：同其他的成员，为整个类体
    static class Inner10{
        private static String name = "中国";
        public void say(){
            //3. 可以直接访问外部类的所有静态成员，包含私有的，但不能直接访问非静态成员
            System.out.println(name);
            cry();//静态内部类---访问---->外部类(比如:静态属性[访向方式直接访问所有静态成员]

            //如果外部类和静态内部类的成员重名时，静态内部类访问的时，默认遵循就近原则，
            // 如果想访问外部类的成员，则可以使用(外部类名.成员) 去访问
            System.out.println(name+" 外部类name="+Outer10.name);

        }
    }

    //5. 作用域 ：同其他的成员，为整个类体
    // 外部其他类---访向---->静态内部类:创建对象，再访问
    public void m1(){
        Inner10 inner10 = new Inner10();
        inner10.say();
    }

    //编写一个方法，返回new Inner10()实例
    public Inner10 getInner(){
        return new Inner10();
    }

    ////编写一个静态方法，返回new Inner10()实例
    public static Inner10 getInner_(){
        return new Inner10();
    }
}

package com.stulzl.innerclass01_exercise01;

//练习 判断输出423
public class InnerClass_Exercise01 {
    public static void main(String[] args) {
        Test t = new Test();//5
        Test.Inner inner = t.new Inner();//这里是外部其他类，调用成员内部类
        System.out.println(inner.a);//5
    }
}
class Test {//外部类
    public Test() {//构造器
        Inner s1 = new Inner();//这里new一个成员内部类实例
        s1.a = 10;//调用a变成10
        Inner s2 = new Inner();//这里又new一个新的成员内部类实例，和前面那个实例没关系
        System.out.println(s2.a);//5
    }

    class Inner { //内部类，成员内部类
        public int a = 5;
    }
}