关于匿名内部类的一些理解

在说匿名类之前，我想先说一下匿名对象的概念
匿名对象：没有名字的对象

匿名对象的应用场景：
1、调用方法的使用，仅仅是调用一次的时候
注意：调用多次的时候，使用匿名对象不合适
那么，为什么还会存在匿名对象呢？
匿名对象在调用完毕之后，由于栈内存中没有引用指向它，那么调用完后，就是一个垃圾空间，可以被垃圾回收器回收

2、匿名对象当作参数传递

class Cat{
    public void eat(){
        System.out.println("猫吃鱼");
    }
}

class CatFactory{
    //当一个类引用数据类型作为参数进行传递的时候，实际上传递的是该类实例化对象的地址值
    public void makeCat(Cat c){ //Cat c = new Cat();
        c.eat();
    }
}

public class AnonymousDemo {
    public static void main(String[] args) {
        Cat c = new Cat();
//        //匿名对象  没有名字的对象
//        new Cat().eat();
//        new Cat().eat(); 
//这里每一次new都相当于在堆内存中创建一个新的对象

        CatFactory cf = new CatFactory();
        //匿名对象当作参数传递
        //下面这两种写法都是正确的
        cf.makeCat(new Cat());
        cf.makeCat(c);
//      甚至于像下面这样写也是正确的
//      new CatFactory().makeCat(new Cat());       
    }
}

在介绍匿名内部类之前，先来说一下内部类

内部类就是将一个类定义在某个类或者方法里面，一共分为四种：成员内部类、局部内部类、匿名内部类、静态内部类

匿名内部类：就是内部类的简化写法
前提：存在一个类或者接口，这里的类可以是具体类也可以是抽象类

定义匿名内部类的语法格式如下
new 类名或者接口名() {重写方法;}

然后还要再提一下多态的概念
多态体现为父类引用变量可以指向子类对象。

下面来看一个例子
首先定义接口，这个接口定义了两个抽象方法，分别是奔跑run()和获取奔跑速度的getSpeed()

package test.AnonymousDemo2;

public interface Run {
    public void run();
    public int getSpeed();

}

接下来，先来看一下匿名内部类长什么样子

package test.AnonymousDemo2;

public class Anonymous2 {
    public void personRun(Run r){
        r.run();
        System.out.println("the man's running speed is "+r.getSpeed());
    }

    public static void main(String[] args) {
        Anonymous2 a = new Anonymous2();

        a.personRun(new Run() {
            @Override
            public void run() {
                System.out.println("can run");
            }

            @Override
            public int getSpeed() {
                return 3;
            }
        });
    }
}

匿名内部类就是这个，实现了接口中的两个抽象方法

new Run() {
            @Override
            public void run() {
                System.out.println("can run");
            }

            @Override
            public int getSpeed() {
                return 3;
            }
        }

最后的输出结果为

实际上，上面的匿名类可以写成

package test.AnonymousDemo2;

public interface Run {
    public void run();
    public int getSpeed();

}

package test.AnonymousDemo2;

public class Run1 implements Run {
    public void run() {
        System.out.println("can run");
    }

    public int getSpeed() {
        return 3;
    }
}

package test.AnonymousDemo2;

public class Anonymous2 {
    public void personRun(Run r){
        r.run();
        System.out.println("the man's running speed is "+r.getSpeed());
    }

    public static void main(String[] args) {
        Anonymous2 a = new Anonymous2();
        Run1 r = new Run1();
        a.personRun(r);
        //这里也可以直接写成
		//a.personRun(new Run1());
    }
}

结果为

两个代码的结果是一样的，其实匿名内部类相当于一个对象

文章的前面提过到过多态，父类的引用变量指向子类对象。这里的Run r 就可以理解为引用变量，然后匿名内部类就会作为实现接口的实例化子类对象，向上转型为Run类型，将对象传入方法personRun中，所以 r 可以调用 run 方法

如果还不清楚的话，还可以看下面这个例子

package test.AnonymousDemo2;

public interface Run {
    public void run();
    public int getSpeed();

}

package test.AnonymousDemo2;

public class Run1{
    public void test(){
        new Run(){
            public void run() {
                System.out.println("can run");
            }

            public int getSpeed() {
                return 3;
            }
        };
    }
}

package test.AnonymousDemo2;

public class Anonymous2 {
    public static void main(String[] args) {
        Run1 r1 = new Run1();
        r1.test();
    }
}

结果什么都不会打印，因为这里的

只是一个对象，什么方法都没有调用，所以什么结果都不会输出

现在将代码修改为

package test.AnonymousDemo2;

public class Run1{
    public void test(){
        new Run(){
            public void run() {
                System.out.println("can run");
            }

            public int getSpeed() {
                return 3;
            }
        }.run();
    }
}

再重新运行main函数

成功调用了 run() 方法