匿名内部类

1、什么是匿名内部类？

　　定义：匿名内部类就是没有名字的内部类，更准确一点，是匿名的局部内部类。

　　匿名内部类出现的前提：必须存在一个类，抽象类，或者接口，来让匿名内部类继承或实现。

　　匿名内部类的格式：

<span style="font-size:14px;">new 类名或者接口名()
		{
			重写类或者接口中的方法。
			也可以自己定义新的方法。
		};
</span>

2、匿名内部类举例并解析？

<span style="font-size:14px;">//定义接口，这是匿名内部类出现的前提
interface Inter
{
	public abstract void show();
	public abstract void show2();
}

//定义外部类
class Outer
{
	//定义方法
	public void method()
	{
		//定义匿名内部类
		new Inter()
		{
			//重写接口中的方法,并调用
			public void show()
			{
				System.out.println("show");
			}
		}.show();
	}
}</span>

<span style="font-size:14px;">//测试类
class InnerTest4 
{
	public static void main(String[] args) 
	{
		Outer o = new Outer();
		o.method(); 
	}
}</span>

　　那么我们可能会问：匿名内部类后边为什么可以直接跟.show();方法呢？

　　这就要剖析一下匿名内部类的本质，我们知道，接口是不可以被new Inter() 的，所以一定有一个继承了接口的类重写了接口的方法，而new出来的就是这个实现了接口的类的对象，对象能够通过.show()调用方法，这样就对了。所以，匿名内部类的正确定义应该是：继承了类或者实现了接口的匿名的子类对象。

3、什么时候使用匿名内部类呢?

　　对于上面例子来说，如果我的接口中定义了show、show1、show2、show3...show100个方法，那么我们就：

<span style="font-size:14px;">                new Inter()
		{
			//重写接口中的方法,并调用
			public void show()
			{
				System.out.println("show");
			}
		}.show();		

		new Inter()
		{
			public void show()
			{
				System.out.println("show");
			}

			public void show2()
			{
				System.out.println("show2");
			}
		}.show1();。。。。。</span>

　　我们要一直show到show100 吗？这样太累了，所以，我们可以使用多态，如： 

<span style="font-size:14px;">		//多态
		Inter i = new Inter()
		{
			public void show()
			{
				System.out.println("show");
			}

			public void show2()
			{
				System.out.println("show2");
			}
			....
			//重写一百个方法。。。累死了
		};

		i.show();
		i.show2();
		.......
		i.show100();</span>

　　但是这样也不行，我们还要重写100个方法，所以匿名内部类第一个使用情况：

　　（1）一般来说，使用匿名内部类的时候接口或者抽象类中的方法都在3个以下。

　　（2）因为匿名内部类要对抽象类或接口进行方法重写，所以以后看到一个方法接收的形式参数是一个抽象类或者接口的时候，就可以考虑采用匿名内部类实现。

4、匿名内部类使用实例？

　　需求：做一个动物接口和一个需要以动物接口作为形式参数的类，然后通过不同方法实现“狗吃骨头。。”

　　（1）传统方法：

<span style="font-size:14px;">//定义动物接口
interface Animal
{
	public abstract void eat();
}

//具体动物狗类
class Dog implements Animal
{
	public void eat()
	{
		System.out.println("狗吃骨头。。");
	}
}

//需要传递接口的类
class Test
{
	//一个方法的形式参数是接口(抽象类)
	public void show(Animal a) //Animal a =  new Dog();
	{
		a.eat();
	}
}

//测试类
class AnimalTest 
{
	public static void main(String[] args) 
	{
		//创建一个test对象
		Test t = new Test();

		 //创建一个狗对象
		Dog d = new Dog();

	}
}</span>

　　（2）匿名内部类：

<span style="font-size:14px;">//定义动物接口
interface Animal
{
	public abstract void eat();
}

//需要传递接口的类
class Test
{
	//一个方法的形式参数是接口(抽象类)
	public void show(Animal a) //Animal a =  new Dog();
	{
		a.eat();
	}
}

//测试类
class AnimalTest 
{
	public static void main(String[] args) 
	{
		//使用匿名内部类
		t.show(new Animal(){
			public void eat()
			{
				//重写方法
				System.out.println("eat dog");
			}
		});
	}
}</span>

　　哪个比较简单，高下立判。使用匿名内部类我们可以直接重写eat() 方法，而不必去创建一个dog类。

小结：匿名内部类的实质是继承了类或者实现了接口的匿名的子类对象。再符合其使用情况下，省去了创建一个继承抽象类或实现接口的类，方便了大家的使用。