java匿名内部类

java匿名内部类

什么是内部类

内部类：在类内部又定义了一个新的类，就被称为内部类。

内部类的分类

• 静态内部类：类似于静态变量
• 实例内部类：类似于实例变量
• 局部内部类：类似于局部变量

内部类是可以用访问修饰符来修饰的

使用内部类编写的代码，可读性很差，所以能不用尽量不用。

下面来看看他们怎么写的：

public class Day7_18_01
{
	//该类在类的内部所以被称为内部类
	//该类是静态的所以是静态内部类
	static class Testt01
	{
	}

	//该类在类的内部，所以叫内部类
	//没有static所以叫做是实例内部类
	class Testt02
	{
	}

	public void doSome(){
		//局部内部类
		class Testt03
		{
		}
	}
	
}

编译一下会生成4个.class文件，其中内部类的文件名中都含有$符号。

因为现在开发中已经很少使用到这几个内部类，所以只需要了解就可以。

匿名内部类

匿名内部类：是局部内部类的一种，因为这个类没有名字而得名，所以叫匿名内部类。

缺点：

• 太复杂、太乱、可读性差
• 类没有名字，以后想重复使用的时候，不能用！

以下面的例子为例引入匿名内部类：

public class Day7_18_01
{
	public static void main(String[] args){
		MyMath m = new MyMath();
		/*
		这里new Computer(){public int sun(int a,int b)；并不是接口可以实例化(都知道接口不能实例化)
		但是接口后面还有{}，但是这个类没有名字，所以叫匿名内部类...，看着有点别扭，不太建议使用，
		因为这样写的时候代码的可阅读性很差，况且后面不能使用...
		*/
		m.doAdd(new Computer(){public int sum(int a,int b){return a+b;}}, 2 , 3);

	}
	
	
}
interface Computer{
	int sum(int a , int b);
}

//这里其实是要实现接口的，但是因为要用匿名内部类嘛，所以就不实现了
/*class ComputerImp implements Computer
{
	public int sun(int a,int b ){
		return a+b;
	}
}*/

class MyMath
{
	//这里接口并没有没实例化，这里其实用到的多态，因为总会有来实现Computer的实现类
	public void doAdd(Computer c , int p , int k ){
		int end = c.sum(p,k);
			System.out.println(end);
	}
}

运行结果：

虽然很不提倡这种写法，但是还是有人这样写，这样代码看着高端…学习匿名内部类主要就是为了看懂人家写的代码而已~

最后来看一下所有所有内部类的代码怎么实现的：

public class  InnerClass
{
	//内部类
	public class Inners
	{
		void fun(){
			System.out.println("我是成员内部类！！！");
		}
	}
	public static void main(String[] args){

		//外部类名称.成员内部类名称   变量名   = new 外部类名称().new 成员内部类(); 
		InnerClass.Inners inner = new InnerClass().new Inners();
		//调用成员内部类
		inner.fun();

		//外部类名称.静态内部类名称  变量名 = new 外部类.静态内部类();
		InnerClass.Innerss in = new InnerClass.Innerss();
		//调用静态内部类
		in.sun();
		
		//外部类名称  变量名 = new 外部类();因为局部内部类只能在方法里面实例化，就好像局部变量只能在局部使用
		InnerClass inn = new InnerClass();
		//调用局部内部类
		inn.funnus();//只需要把局部内部类所在的方法实例化以后调用它，因为局部内部类在方法里面已经实例化了

		//父类名称  变量  = new 父类名称(){重写父类里面的抽象方法};匿名内部类是以继承为基础的
		AbstractClass abstractClass = new AbstractClass(){
			public void fun(){
				System.out.println("我是匿名内部类，我名字都没有你居然还找到我了，看来你是对我真心的好，我爱你~~~");
			}
		};
		//调用匿名内部类
		abstractClass.fun();

		//接口名称  变量  = new 接口名称(){重写接口里面的方法};
		InterfaceClass interfaceClass = new InterfaceClass(){
			public void fun(){
				System.out.println("我也是匿名内部类，不行，不行，姐姐都喜欢你，我也要嫁给你啊！！");
			}
		};
		interfaceClass.fun();
		

	}


	public static class Innerss	{
		public void sun(){
			System.out.println("我是静态内部类里面的方法，你居然找到我了！！！？？？");
		}
	}

	public void funnus(){
		class JuClass
		{
			void fun(){
				System.out.println("我是局部内部类！！你是怎么怎么找到我的，坏人，小锤锤捶你胸口~~~~");
			}
		}
		//只能在方法里面实例局部内部类
		JuClass ju = new JuClass();
		ju.fun();
	}

	

}

abstract class AbstractClass
{
	public abstract void fun();
}

interface InterfaceClass{
	public void fun();	
}

运行结果：