package com.stulzl.innerclass_;

//内部类演示 412
public class InnerClass01 {
    public static void main(String[] args) {
        
    }
}
class Outer{//外部类
    private int n1 = 100;

    //构造器
    public Outer(int n1) {
        this.n1 = n1;
    }
    //方法
    public void m1(){
        System.out.println("m1()");
    }
    //代码块
    {
        System.out.println("代码块……");
    }
    //内部类,在Outer类的内部
    class Inner{
        
    }
}

package com.stulzl.local_innerclass;

//局部内部类  413-414
public class Local_InnerClass {
    public static void main(String[] args) {
        Outer02 outer02 = new Outer02();
        outer02.m1();
    }
}
class Outer02{//外部类
    private int n1 = 100;
    private void m2(){//私有方法
        System.out.println("Outer02 m2()");
    }

    public void m1(){//方法
        //1.局部内部类是定义在外部类的局部位置,通常在方法中
        //3.不能添加访问修饰符，但是可以使用final修饰
        //4.作用域 : 仅仅在定义它的方法或代码块中
        final class Inner02{//局部内部类(本质仍然是一个类)
            private int n1 = 800;
            //2.可以直接访问外部类的所有成员，包含私有的
            public void f1(){
                //5. 局部内部类可以直接访问外部类的成员，比如下面 外部类 n1 和 m2()
                //如果外部类和局部内部类的成员重名时，默认遵循就近原则，如果想访问外部类的成员，
                //使用 外部类名.this.成员）去访问
                //解读 Outer02.this 本质就是外部类的对象, 即哪个
                // 对象调用了 m1, Outer02.this 就是哪个对象
                System.out.println("n1="+n1+" 外部类的n1="+Outer02.this.n1);//输出800  100
                m2();
            }
        }
        //class Inner03 extends Inner02{ }//此时Inner02有final不能被继承

        //5. 外部类在方法中，可以创建 Inner02 对象，然后调用方法即可
        Inner02 inner02 = new Inner02();
        inner02.f1();
    }

    //代码块中也可以定义局部内部类
    {
        class Inner04{}
    }

}

package com.stulzl.anonymous_innerclass;

//匿名内部类 415
public class Anonymous_InnerClass {
    public static void main(String[] args) {
        Outer04 outer04 = new Outer04();
        outer04.method();
    }
}
class Outer04{//外部类
    private  int n1 = 10;//属性

    public void method(){//方法
        //一、基于接口的匿名内部类
        //解读
        //1.需求： 想使用 IA 接口,并创建对象
        //2.传统方式，是写一个类，实现该接口，并创建对象

//        IA tiger = new Tiger();
//        tiger.cry();

        //3. 需求是 Tiger类只是使用一次，后面再不使用
        //4. 可以使用匿名内部类来简化开发
        //5. tiger 的编译类型 ? IA
        //6. tiger 的运行类型 ? 就是匿名内部类 匿名为 Outer04$1
        /*
        我们看底层 会分配 类名 Outer04$1
        class Outer04$1 implements IA {
            @Override
            public void cry() {
                System.out.println("老虎叫唤...");
            }
        }
        */
        //7.jdk 底层在创建匿名内部类 Outer04$1,立即马上就创建了Outer04$1实例，并且把地址返回给tiger
        //8. 匿名内部类使用一次，就不能再使用(意思是匿名内部类只有一次，但是根据他创建的实例tiger可以一直使用)
        IA tiger = new IA(){
            @Override
            public void cry() {
                System.out.println("老虎叫唤……");
            }
        };//注意分号
        tiger.cry();
        tiger.cry();//匿名内部类只有一次，但是根据他创建的实例tiger可以一直使用
        tiger.cry();

        //二、演示基于类的匿名内部类
        //分析
        //1. father 编译类型 Father
        //2. father 运行类型 Outer04$2
        //3. 底层会创建匿名内部类
        /*
        class Outer04$2 extends Father{
            @Override
            public void test() {
                System.out.println("匿名内部类重写了 test 方法");
            }
        }
        */
        //4. 同时也直接返回了 匿名内部类 创建的Outer04$2 的对象 返回给 father
        //5. 注意("jack") 参数列表会传递给 Father构造器
        Father father = new Father("jack"){
            @Override
            public void test() {
                System.out.println("匿名内部类重写了 test 方法");
            }
        };//别忘了分号
       father.test();

        //三、基于抽象类的匿名内部类
        Animal animal = new Animal(){
            @Override
            void eat() {//抽象类不许重写方法
                System.out.println("动物吃骨头……");
            }
        };//别忘了分号
        animal.eat();
    }
}

interface IA{//接口
    public void cry();
}
//class Tiger implements IA{
//    @Override
//    public void cry() {
//        System.out.println("老虎叫唤……");
//    }
//}


class Father{//普通类
    //构造器
    public Father(String name){

    }
    //方法
    public void test(){

    }
}

//抽象类
abstract class Animal{
    abstract void eat();
}

package com.stulzl.anonymous_innerclass_detail;

//匿名内部类细节417
public class Anonymous_InnerClass_Detail {
    public static void main(String[] args) {
        Outer05 outer05 = new Outer05();
        outer05.f1();
        //打印hashcode证明 匿名内部类调用外部类属性时使用的 Outer05.this 就是调用 f1 的 对象即outer05
        System.out.println("Outer05.this hashcode=" + outer05);
    }
}
class Outer05{//外部类
    private int n1 = 99;
    public void f1(){
        //创建一个基于类的匿名内部类
        //不能添加访问修饰符,因为它的地位就是一个局部变量
        //作用域 : 仅仅在定义它的方法或代码块中
        Person person = new Person(){
            private int n1 = 88;
            @Override
            public void hi() {
                //可以直接访问外部类的所有成员，包含私有的
                //System.out.println("匿名内部类重写了hi()方法 n1="+n1);

                //如果外部类和匿名内部类的成员重名时，匿名内部类访问的话，默认遵循就近原则，
                // 如果想访问外部类的成员，则可以使用(外部类名.this.成员)去访问
                System.out.println("匿名内部类重写了hi()方法 n1="+n1+"外部类的n1="+Outer05.this.n1);

                //Outer05.this 就是调用 f1 的 对象
                System.out.println("Outer05.this hashcode=" + Outer05.this);//打印hashcode
                //证明Outer05.this 就是调用 f1 的 对象即outer05
            }
        };
        person.hi();//涉及动态绑定，运行类型Outer05$1

        //也可以直接调用, 匿名内部类本身也是返回对象
        // class 匿名内部类 继承了 extends Person {}
        Person person1 = new Person(){
            @Override
            public void hi() {
                System.out.println("匿名内部类重写了hi()方法，哈哈……");
            }

            @Override
            public void ok(String name) {
                super.ok(name);
            }
        };
        person1.hi();
        person1.ok("jack");
    }
}
class Person{
    public void hi(){
        System.out.println("Person hi()");
    }

    public void ok(String name){
        System.out.println("ok()="+name);
    }
}

package com.stulzl.anonymous_innerclass_exercise01;

//匿名内部类最佳实践 418
public class Anonymous_InnerClass_Exercise01 {
    public static void main(String[] args) {

        //使用匿名内部类 当作实参直接传递，简洁高效(自我理解是相当于把运行类型当参数传走了)
        f1(new IL() {
            @Override
            public void show() {
                System.out.println("这是一副名画~~……");
            }
        });
        //写完全就是这样的
//        IL il = new IL(){  //其实匿名内部类就是系统自己写了一个类和show方法，然后将这个实例对象指向了il
//            @Override      //这个对象实例就相当于普通方法的Picture，只是名字(系统取得)不一样而已
//            public void show() {
//                System.out.println("这是一副名画……");
//            }
//        };
//        f1(il);


        //传统方法
        Picture picture = new Picture();
        f1(picture);
    }

    //写一个方法,调用接口方法
    public static void f1(IL il){//这里涉及多态和动态绑定，编译类型 IL 运行类型是 Picture
        il.show();//调用接口方法
    }
}

interface IL{//接口
    void show();
}

//传统方法，实现接口方法  (这种比较死板的方法编程领域叫硬编码)
class Picture implements IL{
    @Override
    public void show() { //实现接口方法
        System.out.println("这是一副名画……");
    }
}

package com.stulzl.anonymous_innerclass_exercise02;

//匿名内部类最佳实践 练习02 418
/*
1.有一个铃声接口 Bell，里面有个 ring 方法。(右图)
2.有一个手机类 Cellphone，具有闹钟功能 alarmClock，参数是 Bell 类型(右图)
3.测试手机类的闹钟功能，通过匿名内部类(对象)作为参数，打印：懒猪起床了
4.再传入另一个匿名内部类(对象)，打印：小伙伴上课了
*/
public class Anonymous_InnerClass_Exercise02 {
    public static void main(String[] args) {

        Cellphone cellphone = new Cellphone();

        //解读
        //1. 传递的是实现了 Bell 接口的匿名内部类 InnerClassExercise02$1
        //2. 重写了 ring
        cellphone.alarmClock(new Bell() {//传类名
            @Override
            public void ring() {
                System.out.println("懒猪起床了……");
            }
        });
        cellphone.alarmClock(new Bell() {
            @Override
            public void ring() {
                System.out.println("小伙伴上课了……");
            }
        });
    }
}
interface Bell{//接口
    void ring();
}

//方法，调用接口方法
class Cellphone{
    public void alarmClock(Bell bell){//涉及多态
        bell.ring();//动态绑定
    }
}