匿名内部类

匿名内部类

继承式的匿名内部类

什么是匿名内部类

匿名内部类就是没有名字的内部类

完整demo代码：

MyClass：

package com.lin183.time;

public class MyClass {
   
	public void testMyclass() {
		System.out.println("Myclass的实例方法");
	}
}

Student：

package com.lin183.time;

public class Student {

	public void testeStudent(MyClass mc) {
		System.out.println("Student类的实例方法");
	}
}

SunClass：

package com.lin183.time;

public class SunClass extends MyClass {
	
}

TestClass

package com.lin183.time;

public class TestClass {

	public static void main(String[] args) {
		// 访问Student类中的TestStuden实例方法
		//我们就需要一个MyClass类型的参数
		//1.传递MyClass类的对象
		Student stu1=new Student();
		MyClass mc=new MyClass();
		stu1.testeStudent(mc);
		
		//2.传递MyClass类的子类对象
		Student stu2=new Student();
		SunClass sun1=new SunClass();
		stu2.testeStudent(sun1);
		
		//3.传递上转型对象
		Student stu3=new Student();
		MyClass mcc=new SunClass();
		stu3.testeStudent(mcc);
		//无论我们传递的是MyClass类的子类对象，还是上转型对象，我们都需要创建一个MyClass类的子类。
		//如果我们不愿意创建MyClass类的子类，这是我们就无法传递的是MyClass类的子类对象，还是上转型对象
		//我们可以使用1匿名内部类来构造TestStuden方法的参数
		Student stu=new Student();
		stu.testeStudent(new MyClass() {
			public void testMyclass() {
				System.out.println("重写MyClass类中的实例方法");
			}
			
		});
		stu.testeStudent(sun1);
		
		//典型的匿名内部类的结果
		//这种匿名内部类的结构就相当于我们为MyClass抽象类创建了一个子类，只是我们创建的这个子类没有固定的名称，所以才叫匿名内部类
		/**
		 * new MyClass() {
			public void testMyclass() {
				System.out.println("重写MyClass类中的实例方法");
			}			
		}
		 */
	}

}

匿名内部类分为两种

第一种：继承式的匿名内部类

a) 当一个方法的参数是抽象类类型的时候，可以是传递子类对象、上转型对象

b) 子类对象、上转型对象在创建的时候需要独立构建一个子类。

典型匿名内部类

这种匿名内部类的结构就相当于我们为MyClass抽象类创建了一个子类，只是我们创建的这个子类没有固定的名称，所以才叫匿名内部类

new MyClass() {
			public void testMyclass() {
				System.out.println("重写MyClass类中的实例方法");
			}			
		}

访问Student类中的TestStuden实例方法，我们就需要一个MyClass类型的参数。

传递参数方法：

1.传递MyClass类的对象

Student stu1=new Student();
		MyClass mc=new MyClass();
		stu1.testeStudent(mc);

2.传递MyClass类的子类对象

​ 需要构建一个MyClass类的子类

子类SunClass代码

package com.lin183.time;

public class SunClass extends MyClass {
	
}

Student stu2=new Student();
		SunClass sun1=new SunClass();
		stu2.testeStudent(sun1);

3.传递上转型对象

​

Student stu3=new Student();
		MyClass mcc=new SunClass();
		stu3.testeStudent(mcc);

无论我们传递的是MyClass类的子类对象，还是上转型对象，我们都需要创建一个MyClass类的子类。

思考：如果我们不愿意创建MyClass类的子类，这时我们就无法传递的是MyClass类的子类对象，还是上转型对象。

答：我们可以使用匿名内部类来构造TestStuden方法的参数

改造：把MyClass变成抽象类：

package com.lin183.time;

public absolute class MyClass {
   
	public void testMyclass() {
		System.out.println("Myclass的实例方法");
	}
}

这是要想让这个Student的testStudent正常调用只能用：传递上转型对象或者传递MyClass类的子类对象，同时我们需要创建一个子类

如果不愿意创建子类的情况下我们可以使用匿名内部类来构造testStudent方法的参数

Student stu=new Student();
		stu.testeStudent(new MyClass() {
			public void testMyclass() {
				System.out.println("重写MyClass类中的实例方法");
			}		
		});

这种匿名内部类的结构就相当于我们为MyClass抽象类创建了一个子类，只是我们创建的这个子类没有固定的名称，所以才叫匿名内部类

总结：

由于产生这个匿名内部类的是一个抽象类，所以我们把这种形式叫继承的匿名内部类

优点：

​ 不需要额外创建某一个类的子类

缺点：

​ 不容易理解

接口匿名内部类

代码：

MyInterface：

package com.lin183.time2;

public interface MyInterface {
	
	//抽象方法
	void testinterface();
}

Student

package com.lin183.time2;

public class Student {

	public void testeStudent(MyInterface mi) {
		System.out.println("Student类的实例方法");
	}
}

TestClass

package com.lin183.time2;

public class TestClass {

	public static void main(String[] args) {
		// 访问Student类中的TestStuden实例方法
		//我们就需要一个MyInterface类型的参数
		//1.传递实现该接口的子类对象
		//2.传递接口回调对象
		//无论是传递实现该接口的子类对象还是传递接口回调对象，我们都要去为这个接口创建一个子类
		//我们不想为这个接口单独创建有个子类，这时我们可以使用匿名内部类来处理
		Student stu1=new Student();
		stu1.testeStudent(new MyInterface() {
			
			@Override
			public void testinterface() {
				// TODO Auto-generated method stub
				
			}
		});
	}
}

典型的接口匿名内部类：

new MyInterface() {
			
			@Override
			public void testinterface() {
				// TODO Auto-generated method stub
				
			}
		}

上面的结构就是一个匿名内部类的结构，他不是在创建MyInterface这个接口的子类对象，只是创建出来的子类没有固定的名称，所以才叫匿名内部类

总结：

由于这个匿名内部类是一个接口，所以我们把这种形式的接口式叫匿名内部类

优点：减少独立子类的创建

缺点：不易理解