【java进阶05：内部类与匿名内部类】

/*
    匿名内部类：
        1、什么是内部类？
            内部类：在类的内部又定义了一个新的类，被称为内部类

        2、内部类的分类：
            静态内部类：类似于静态变量
            实例内部类：类似于实例变量
            局部内部类：类似于局部变量

        3、使用内部类编码的代码，可读性很差，能不用尽量不用。

        4、匿名内部类是局部内部类的一种
            因为这个类没有名字而得名，叫做匿名内部类。

        5、学习匿名内部类主要是让大家以后在阅读别人代码的时候，能够理解。
        并不代表以后都要这样写，因为匿名内部类有两个缺点：
            1：太复杂，太乱，可读性差
            2：类没有名字，不能复用

 */
public class Text1 {

    //静态变量
    static String c;
    //该类在类的内部，所以成为内部类
    //由于前面有static，所以称为“静态内部类”
    static class Inner1{

    }

    //实例变量
    int k ;
    //该类在类的内部，所以称为内部类
    //没有static，所以称为“实例内部类”
    class Inner2{
    }



    //方法
    public void doSome(){
        //局部变量
        int i = 100;

        //该类在类的内部，所以称为内部类
        //在方法内，所以是局部内部类
        class Inner3{

        }
    }

    public void doOther(){
        //doSome()方法中的局部内部类Inner3在doOther()中不能调用
    }
    public static void main(String[] args){
        //调用MyMath中的mySum方法
        MyMath mm = new MyMath();
        //这里因为调用的是Compute接口实现求和，所以要传进来一个Compute对象
        // 但是由于接口不能new对象，所以要为这个接口写一个实现类，然后再传进来
        //Error: Compute是抽象的; 无法实例化
        //mm.mySum(new Compute(),100,100 );

        //这样写代码，表示这个类名是有的，类名是：ComputerImpl
            //mm.mySum(new ComputeImpl(),100,10);

        //使用匿名内部类，表示之前要实现Compute接口的ComputeImpl这个类没名字了
        //表面看上去像是接口可以直接new了，但实际上并不是接口可以new，而是后面的{}代表了对接口的实现。
        //但不建议使用匿名内部类，为什么？
        //因为一个类没有名字，没有办法重复使用，另外代码太乱，可读性太差。
        mm.mySum(new Compute() {
            @Override
            public int sum(int a, int b) {
                return a+b;
            }
        }, 100, 100);
    }
}

//负责计算的接口
interface Compute{
    //抽象方法
    int sum(int a ,int b);
}

自动会在这里编写一个Compute接口的实现类
//class ComputeImpl implements Compute{
//    //对方法的实现
//    public int sum(int a ,int b){
//        return a+b;
//    }
//}


//数学类
class MyMath{
    //数学求和方法
    public void mySum(Compute c , int x ,int y){
        int retValue = c.sum(x,y);
        System.out.println(x+"+"+y+"="+retValue);
    }
}

当new的对象后面有{}时，这就是一个匿名内部类。只是new的不是一个接口的匿名内部类，而是一个类的，相当于匿名重写方法。所以当我们又加了一个{}，表示的含义，其实就是一个代码块。

//这种new类对象时后面跟一个{}，其中重写该类方法的形式，算是一种匿名子类的写法或是重写父类方法的一种形式。  
Handler handler = new Handler() {
    public void handleMessage(@NonNull Message msg) {
        super.handleMessage(msg);
    }
};