Java特别篇--匿名对象与匿名内部类

很多小伙伴对匿名对象和匿名内部类的写法有点陌生，这里专门写一篇来帮助大家认识一下他们的写法。

一、匿名对象

比如现在有一个Student类，里面啥也没有写：

/**
 * ClassName: Student
 * Package: PACKAGE_NAME
 * Description:
 *
 * @Author 雨翼轻尘
 * @Create 2024/1/31 0031 11:39
 */
public class Student {

}

然后还有一个测试类Test：

/**
 * ClassName: Test
 * Package: PACKAGE_NAME
 * Description:
 *
 * @Author 雨翼轻尘
 * @Create 2024/1/31 0031 11:39
 */
public class Test {
    public static void main(String[] args) {
        //类->对象  格式：类名Student 对象名stu = new 类名Student();
        Student stu=new Student();
    }
}

️类->对象

格式：类名Student 对象名stu = new 类名Student();

如下：

public class Test {
    public static void main(String[] args) {
        //类->对象  格式：类名Student 对象名stu = new 类名Student();
        Student stu=new Student();
    }
}

现在打印出来就是地址值：

如果这样，也是地址值：

每new一次，就会创建一个对象，相当于在堆中开辟了一块空间，所以地址值都不一样，如下：

public class Test {
    public static void main(String[] args) {
        //类->对象  格式：类名Student 对象名stu = new 类名Student();
        Student stu=new Student();
        System.out.println(stu);    //test.Student@4eec7777
        System.out.println(new Student());  //test.Student@3b07d329
        System.out.println(new Student());  //test.Student@41629346
    }
}

上面的stu是有名字的对象，而现在的new Student()没有对象名，叫做匿名对象。

有了new关键字，就表示在堆里面创建了一个新的空间。

---

现在在Student类里面加上属性，比如：

public class Student {
    String name;    //姓名
}

正常情况下，name可以赋值：

public class Test {
    public static void main(String[] args) {
        //类->对象  格式：类名Student 对象名stu = new 类名Student();
        Student stu=new Student();
        System.out.println(stu);    //test.Student@4eec7777
        stu.name="张三";
        System.out.println(stu.name);   //张三

    }
}

打印出来就是“张三”：

那么new Student()可以给name赋值吗？

是可以的。

它是一个匿名对象，虽然没有名字，但是它可以给属性赋值的。如下：

public class Test {
    public static void main(String[] args) {
        System.out.println(new Student().name="李四");  //test.Student@3b07d329
        System.out.println(new Student());  //test.Student@41629346
    }
}

输出：

---

“匿名对象”只不过是一个没有名字的对象而已，依然是一个对象。

若是方法依然可以调用的，比如现在写一个方法eat，如下：

public class Student {
    String name;    //姓名

    public void eat(){
        System.out.println("使劲吃...");
    }
}

测试类里面：

public class Test {
    public static void main(String[] args) {
        //类->对象  格式：类名Student 对象名stu = new 类名Student();
        Student stu=new Student();
        System.out.println(stu);    //test.Student@4eec7777
        stu.name="张三";
        System.out.println(stu.name);   //张三
        stu.eat();

        System.out.println(new Student().name="李四");  //test.Student@3b07d329
        System.out.println(new Student());  //test.Student@41629346
        new Student().eat();
    }
}

输出结果：

像这样直接new了一个类名，但是没有给对象名的，叫做“匿名对象”。

区别就是，有名的对象它可以多次使用，而匿名对象却只能使用一次。

二、匿名内部类

提供一个接口IA，里面写一个抽象方法play，如下：

package test;

/**
 * ClassName: IA
 * Package: test
 * Description:
 *
 * @Author 雨翼轻尘
 * @Create 2024/1/31 0031 12:08
 */
public interface IA {
    //抽象方法
    void play();
}

抽象方法省略了public abstract。

抽象方法要想重写，需要有子类去实现这个接口。

接下来写一个实现类IAImpl，将接口里面的抽象方法重写一下，如下：

package test;

/**
 * ClassName: IAImpl
 * Package: test
 * Description:
 *
 * @Author 雨翼轻尘
 * @Create 2024/1/31 0031 12:12
 */
public class IAImpl implements IA{
    @Override
    public void play() {
        System.out.println("打游戏...");
    }
}

然后再来一个测试类IATest，以多态的方式创建接口：

package test;

/**
 * ClassName: IATest
 * Package: test
 * Description:
 *
 * @Author 雨翼轻尘
 * @Create 2024/1/31 0031 12:14
 */
public class IATest {
    public static void main(String[] args) {
        IA ia=new IAImpl(); //多态
    }
}

IA ia=new IAImpl(); ，接口不能传对象，口诀：多态–“父父new子”。

实现类可以看成继承关系。

现在来使用ia调用play方法：

public class IATest {
    public static void main(String[] args) {
        IA ia=new IAImpl(); //多态
        ia.play();	//编译看左，运行看右
    }
}

输出：

ia.play(); “编译看左，运行看右”，接口IA里面有play方法，它被实现类IAImpl重写了，所以执行的时候是看实现类里面的。

---

现在我们来看一下这个蓝色部分，这个括号里面只有一个方法的重写：

之前说接口不能new，我们来看一下这样：

看一下刚才的两个蓝色部分，有什么区别？

没有区别！只不过右边多了一个最后的分号。

既然花括号里面的内容和实现类的一模一样，那我们可以使用i调用里面的方法play，如下：

public class IATest {
    public static void main(String[] args) {
        IA ia=new IAImpl(); //多态
        ia.play();  //编译看左，运行看右

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

        IA i=new IA() {
            @Override
            public void play() {
                System.out.println("打游戏哈哈哈...");
            }
        };

        i.play();
    }
}

打印输出：

可以看到，调用的是花括号里面重写IA接口的方法。

我们new了一个接口之后，后面的大括号里面可以看作一个类的结构。如下：

在花括号里面是对方法的重写，重写的是IA接口的抽象方法。

---

现在写一个IB接口：

public interface IB {
    //抽象方法
    void sleep();
}

再写一个测试类IBTest：

public class IBTest {
    public static void main(String[] args) {

    }
}

目前IB接口没有实现类，还可以创建对象吗？

可以的，如下：

public class IBTest {
    public static void main(String[] args) {
        IB ib=new IB() {
            @Override
            public void sleep() {

            }
        };
    }
}

这个结构和它的实现类结构是一样的（蓝色部分）：

现在就不需要接口的实现类了，上面蓝色部分就是它的匿名实现类。

通过ib.sleep()来调用重写的抽象方法：

public class IBTest {
    public static void main(String[] args) {
        IB ib=new IB() {
            @Override
            public void sleep() {
                System.out.println("睡觉...");
            }
        };

        ib.sleep();
    }
}

输出：

这就是匿名内部类，new的接口，相当于是把实现类的结构拿了过来，重写了一下。

---

还有一种写法。

刚才说了匿名对象，可以直接拿匿名对象去调用方法。

同样，我们还可以使用匿名内部类直接调用方法。

这个叫做创建“匿名实现类的有名对象”，如下结构：

IB ib = new IB(){
    //sleep()方法的重写
};
ib.sleep();	//用ib调用方法sleep()

现在我们直接new一个接口IB：

new IB(){
    //sleep()方法的重写
}

然后直接用它调用sleep()方法，如下：

new IB(){
    //sleep()方法的重写
}.sleep();

代码

public class IBTest {
    public static void main(String[] args) {
        IB ib=new IB() {
            @Override
            public void sleep() {
                System.out.println("睡觉...");
            }
        };

        ib.sleep();

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

        new IB(){
            @Override
            public void sleep() {
                System.out.println("晚安喽");
            }
        }.sleep();
    }
}

输出

这里的ib就表示：

那就可以直接拿它调用sleep()方法：

---

看一下正常的一般写法：

再看一下这两种方式：