Java中匿名对象和匿名内部类总结

最新推荐文章于 2024-01-31 13:19:30 发布

安慕希ai

最新推荐文章于 2024-01-31 13:19:30 发布

阅读量1k

点赞数 2

分类专栏： JAVA 文章标签： java

原文链接：https://blog.csdn.net/Tobin_Xu/article/details/78881617?ops_request_misc=&request_id=&biz_id=102&utm_term=java%E4%B8%AD%E7%9A%84%E5%8C%BF%E5%90%8D%E7%B1%BB&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduweb~default-4-78881617.pc_search

版权

JAVA 专栏收录该内容

38 篇文章 1 订阅

订阅专栏

一、匿名对象

1、匿名对象的创建

匿名对象是指在创建对象时，只有创建对象的语句，却没有把对象地址赋值给某个变量，如：对于已存在的Person类：

创建一个普通对象
Person P = new Person();
创建一个匿名对象
new Person();

2、匿名对象的特点

创建匿名对象可以直接使用，没有变量名
new Person().work(); //work 方法被一个没有名字的 Person 对象调用了
匿名对象在没有指定其引用变量时，只能使用一次
new Person().work(); //创建一个匿名对象，调用 work 方法
new Person().work(); //想再次调用 work 方法，要重新创建一个匿名对象
匿名对象可以作为方法接收的参数，方法返回值使用

class Demo {
    public static Person getPerson(){
        //普通方式
        //Person p = new Person();	
        //return p;
 
        //匿名对象作为方法返回值
        return new Person();
    }
 
    public static void method(Person p){}
}
 
class Test {
    public static void main(String[] args) {
        //调用getPerson方法，得到一个Person对象
        Person person = Demo.getPerson();
 
        //调用method方法
        Demo.method(person);
        //匿名对象作为方法接收的参数
        Demo.method(new Person());
    }
}

二、匿名内部类

匿名内部类也就是没有名字的内部类
正因为没有名字，所以内部类只能使用一次，它通常用来简化代码编写
但使用匿名内部类还有个前提条件：必须继承一个父类或实现一个接口

实例1：不使用匿名内部类来实现抽象方法

abstract  class  Person {
     public  abstract  void  eat();
}
 
class  Child  extends  Person {
     public  void  eat() {
         System.out.println( "eat something" );
     }
}
 
public  class  Demo {
     public  static  void  main(String[] args) {
         Person p =  new  Child();
         p.eat();
     }
}

运行结果：eat something
可以看到，我们用Child继承了Person类，然后实现了Child的一个实例，将其向上转型为Person类的引用

但是，如果此处的Child类只使用一次，那么将其编写为独立的一个类岂不是很麻烦？
这个时候就引入了匿名内部类

实例2：匿名内部类的基本实现

abstract  class  Person {
     public  abstract  void  eat();
}
 
public  class  Demo {
     public  static  void  main(String[] args) {
         Person p =  new  Person() {
             public  void  eat() {
                 System.out.println( "eat something" );
             }
         };
         p.eat();
     }
}

运行结果：eat something
可以看到，我们直接将抽象类Person中的方法在大括号中实现了
这样便可以省略一个类的书写

并且，匿名内部类还能用于接口上

实例3：在接口上使用匿名内部类

interface  Person {
     public  void  eat();
}
 
public  class  Demo {
     public  static  void  main(String[] args) {
         Person p =  new  Person() {
             public  void  eat() {
                 System.out.println( "eat something" );
             }
         };
         p.eat();
     }
}

运行结果：eat something

由上面的例子可以看出，只要一个类是抽象的或是一个接口，那么其子类中的方法都可以使用匿名内部类来实现

最常用的情况就是在多线程的实现上，因为要实现多线程必须继承Thread类或是继承Runnable接口

实例4：Thread类的匿名内部类实现

public  class  Demo {
     public  static  void  main(String[] args) {
         Thread t =  new  Thread() {
             public  void  run() {
                 for  ( int  i =  1 ; i <=  5 ; i++) {
                     System.out.print(i +  " " );
                 }
             }
         };
         t.start();
     }
}

运行结果：1 2 3 4 5

实例5：Runnable接口的匿名内部类实现

public  class  Demo {
     public  static  void  main(String[] args) {
         Runnable r =  new  Runnable() {
             public  void  run() {
                 for  ( int  i =  1 ; i <=  5 ; i++) {
                     System.out.print(i +  " " );
                 }
             }
         };
         Thread t =  new  Thread(r);
         t.start();
     }
}

运行结果：1 2 3 4 5
注意：

匿名内部类中，我们的格式是：
父类名或者接口名引用变量 new 父类名或者接口名(){

1、对于类而言，这个类可以是抽象的也可以不是抽象的如果是抽象的且里面有抽象的方法，必须实现父类中的抽象方法当然也可以重写不是抽象的方法。
2、对于接口而言对应的抽象方法必须得实现。如果接口中定义的有default方法(jdk8之后接口中是可以定义default方法、静态方法的。对于静态方法属于类，不会有重写的)，则在这里面也可以进行重写。

}
值得说明的是:上述声明匿名内部类格式中：new 父类名或者接口名时其实new的是其子类，因为我们知道抽象类和接口是不可以造对象的只能是其子类或者实现类才可以造对象，虽然我们显示的写的是new 父类名或者接口名，但要明白其实是new 了一个继承了该类或者实现了该接口的子类匿名对象。这个子类没有名字，所以我们就叫做了匿名内部类。

虽然我们显示的写的是new 父类名或者接口名，但要明白其实是new 了一个继承了该类或者实现了该接口的子类匿名对象。对其进行代码演示

public class Children extends Father{
	public static void main(String[] args) {
		Children c=new Children();
		System.out.println(c.getClass());
		
		//这说明匿名内部类可以重新父类的方法的
		Father f=new Father(){
			public void money(){
				//重写了父类中不是抽象的方法
				System.out.println("儿子有1000万");
			}
		};
		f.money();
		System.out.println(f.getClass().getSuperclass());
		//class com.liuyongbin.abstracttest.Father
		//这句话输出的是f的父类，可见f是Father的子类，
		//即使你写的是
		//Father f=new Father()
	}
}
 class Father{
	public void money(){
		System.out.println("老爸有100万");
	}
}

二、匿名类和匿名对象的组合

存在四种：

对于类：
1、非匿名的类匿名的对象
2、非匿名的类非匿名的对象
3、匿名的子类匿名的对象
4、匿名的类非匿名的对象

public class AnonymousSubClassOfAbstractClass {
	
	public static void method1(Person p){
		p.eat();
		p.breath();
	}
	
	public static void method(Student s){
		
	}
	
	public static void main(String[] args) {
		
		method(new Student());//匿名对象
		Worker worder=new Worker();
		method1(worder);//非匿名的类非匿名的对象
		
		method1(new Worker());//非匿名的类匿名的对象
		
		System.out.println("-------");
		
		//创建了一个匿名子类的非匿名的对象：这里可不是Person类的对象
		//而是其子类的，因为我们知道抽象类是不能造对象的，所以我们
		//虽然形式上看着是Person类的对象，实质上是Person子类的对象
		Person p=new Person(){

			@Override
			public void eat() {
				System.out.println("吃东西");
			}

			@Override
			public void breath() {
				System.out.println("好好吸气");
			}
		};
		
		//匿名子类的匿名对象
		new Person(){

			@Override
			public void eat() {
					System.out.println("我爱吃");	
			}

			@Override
			public void breath() {
				System.out.println("我还睡");
			}
		};
		
	}
}

class Worker extends Person{

	@Override
	public void eat() {
		
	}

	@Override
	public void breath() {
		
	}
	
}

对于接口：
1、接口的非匿名实现类的非匿名对象
2、接口的非匿名实现类的匿名对象
3、接口的匿名实现类的非匿名对象
4、接口的匿名实现类的匿名对象

public class USBTest {
	public static void main(String[] args) {
		
		Computer com=new Computer();
		//1.创建了接口的非匿名实现类的非匿名对象
		Flash flash=new Flash();
		com.transferData(flash);
		
		//2.创建了接口的非匿名实现类的匿名对象
		com.transferData(new Printer());
		
		//3.创建了接口的匿名实现类的非匿名对象
		USB phone =new USB(){//注意：这里虽然写的是new USB()其实是new的它的子类(所以说创建了接口的匿名实现类)
			//因为接口都不能有构造器，怎么能造对象呢

			@Override
			public void start() {
				System.out.println("手机开始工作");
			}

			@Override
			public void stop() {
				System.out.println("手机结束工作");
			}
		};
		com.transferData(phone);
		
		//4.创建了接口的匿名实现类的匿名对象
		com.transferData(new USB(){

			@Override
			public void start() {
				System.out.println("mp3开始工作");
			}

			@Override
			public void stop() {
				System.out.println("mp3停止工作");
			}			
		});
		
		/*
		 * U盘开启工作
			具体传输数据的细节
			U盘结束工作
			打印机开启工作
			具体传输数据的细节
			打印机结束工作
			手机开始工作
			具体传输数据的细节
			手机结束工作
			mp3开始工作
			具体传输数据的细节
			mp3停止工作

		 */
	}
}

interface USB{
	
	//常量：定义了长、宽、最大最小的传输速度等
	
	public abstract void start();
	void stop();
}

class Computer{
	
	public void transferData(USB usb){//USB usb=new Flash();//多态
		
		usb.start();
		System.out.println("具体传输数据的细节");
		
		usb.stop();
	}
}

class Flash implements USB{

	@Override
	public void start() {
		System.out.println("U盘开启工作");
	}

	@Override
	public void stop() {
		System.out.println("U盘结束工作");
	}
	
}

class Printer implements USB{

	@Override
	public void start() {
		System.out.println("打印机开启工作");
	}

	@Override
	public void stop() {
		System.out.println("打印机结束工作");
	}
	
}

参考文章：参考

安慕希ai

关注

2
点赞
踩
16

收藏

觉得还不错? 一键收藏
0
评论
Java中匿名对象和匿名内部类总结

一、匿名对象匿名对象是指在创建对象时，只有创建对象的语句，却没有把对象地址赋值给某个变量，如：对于已存在的Student类：创建一个普通对象Student st=new Student();项目
复制链接

扫一扫