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()方法：
🚗看一下正常的一般写法：
再看一下这两种方式：
到此这篇关于Java 匿名对象与匿名内部类的使用的文章就介绍到这了,更多相关Java 匿名对象与匿名内部类内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！