JAVA基础之内部类

内部类：定义在类中的类叫内部类。


内部类的访问特点：
1.内部类可以直接访问外部类中的成员。
2.外部类要访问内部类，必须先创建内部类的对象。


内部类的使用：一般用于类的设计。
分析事物时，发现该事物描述中还有事物，而且这个事物还在访问描述事物的内容。
这时就可以将事物中的事物定义成内部类来描述。

比如：

class Love
{
	private String love="随意";
	private static  String like="随便";//因为静态只能访问静态，所以like变量也得是静态的。
	class Like
	{
		void show()
		{
			System.out.println("show run..."+love);
		}
	}
	static class love//这是一个静态的内部类，相当于一个外部类。
	{
		void show()
		{
			System.out.println("show run..."+like);
		}
		static void like()//如果内部类中定义了静态成员，那么该内部类也必须是静态的。
		//因为静态成员是随着类的加载而存在的，当外部类开始加载的时候，内部类不是静态就无法存在
		//更谈不上访问内部类中的静态成员。
		{
			System.out.println("遇见"+like);
		}
	}
	public void getLove()
	{
		Like l =new Like();
		l.show();
	}
}

内部类直接访问外部类中的成员：
内部类需持有外部类的引用。格式为：外部类名.this

比如

class orange
{
	String love="烦";
	class apple
	{
		String love="迷茫";
		void show()
		{
			String love="去";
			System.out.println(love);//方法存在与栈内存中，当栈内存与堆内存存在相同变量时
			//获取的是栈内存中的变量值，所以这个打印出来的是“茵茵”
			System.out.println(this.love);//用了this关键字，输出的就是对象中的变量值。
			//所以这句输出的是“迷茫”
			System.out.println(orange.this.love);//用了外部类名就可以输出（调用）外部类的成员变量。
			//所以这句输出的是“烦”
		}
	}
	public void work()
	{
		new apple().show();//这是匿名对象调用。
	}
}

内部类也可以存放在局部位置上。
内部类在局部位置上只能访问局部中被final修饰的局部变量。
比如：

class hello
{
	String a="哈哈";
	void show()
	{
		int b=8;//在JDK8版本以前，这个局部变量必须要加final关键字才能被内部类的方法所访问，否则就会报错。
		//因为方法执行完后就弹栈了，内部类中的方法就访问不到这个局部变量。
		//加final关键字的意思就是固定这个值。
		//虽然JDK8以后不用加final关键字也能编译运行，但是这个变量值依然不可更改，更改即报错。
		class world
		{
			void geta()
			{
				System.out.println(b);
			}
		}
		new world().geta();
	}
}

匿名内部类：
其实就是内部类的简写格式。

他的前提是：
内部类必须继承或者实现一个外部类或者接口。


匿名内部类：其实就是一个匿名子类对象。
格式：new 父类名or接口名(){子类内容}


比如：

abstract class Why
{
	abstract void show();
}
class Who
{
	int num=7;
	class You extends Why//这是普通内部类继承外部类。
	{
		void show()
		{
			System.out.println(num);
		}
	}
	void work()
	{
		new You().show();
		new Why()//这是匿名内部类，直接用父类名创建子类对象，并覆盖父类中的方法。
		{
			void show()
			{
				System.out.println(num);
			}
		}.show();//.show();就是在调用匿名内部类中的方法。
	}
}

匿名内部类的应用场景之一：
当函数参数是接口类型时，而且接口中的方法不超过三个。
可以用匿名内部类作为实际参数进行传递。
比如：

interface Inter
{
	void show1();
	void show2();
}
class Niming
{
	class Inner implements Inter//这是一般方法。
	{
		public void show1()
		{
			System.out.println("真的爱你");
		}
		public void show2()
		{
			System.out.println("喜欢你");
		}
	}
	void show3()
	{
		Inner in=new Inner();
		in.show1();
		in.show2();
		System.out.println("---------");
		Inter ia=new Inter()//这是匿名内部类的方法。当父类（接口）方法超过一个时可用多态形式命名新对象。
		{//然后以父类类型命名匿名对象进行调用多个方法。
			public void show1()
			{
				System.out.println("真的爱你");
			}
			public void show2()
			{
				System.out.println("喜欢你");
			}
		};
		ia.show1();
		ia.show2();
	}
}
class TangYi
{
	void show()
	{
		new Object()
		{
			void show1()
			{
				System.out.println("狂人山庄");
			}
		}.show1();//这个可以运行。
		Object obj=new Object()
		{
			void show2()
			{
				System.out.println("乐与怒");
			}
		};
		obj.show2();//这个会挂掉，编译失败。
		/*因为虽然创建的是子类对象，但是类类型是父类的，也就是多态形式。
		Object是没有定义任何方法的，所以show2()的方法就是子类特有的。
		父类类型的子类对象当然访问不到子类的特有内容。
		（匿名内部类这个子类对象被向上转型成了Object类型，这样就无法访问子类的特有方法）*/
	}
}
class NeiBulei  
{
	public static void main(String[] args) 
	{
		Love l= new Love();
		l.getLove();
		//还有一种不多见的访问形式，就是直接访问外部类中的内部类中的成员。比如：
		Love.Like a=new Love().new Like();//所属关系一定要写对，否则无法访问。
		a.show();
		System.out.println("---------");
		//如果内部类是静态的，这时就相当于一个外部类。
		Love.love b=new Love.love();
		b.show();
		System.out.println("---------");
		//如果内部类是静态的，而且内部类中的成员也是静态的。那我们可以直接类名调用。
		Love.love.like();
		System.out.println("---------");
		new orange().work();//匿名对象调用。
		System.out.println("---------");
		new hello().show();
		System.out.println("---------");
		new Who().work();
		System.out.println("---------");
		new	Niming().show3();
		System.out.println("---------");
		show(new Inter()//这里可以看出，如果方法过多，阅读性就相当差了。
		{//而且这里和内部类其实没什么关系了，只是一个匿名子类，也就是匿名对象。
			public void show1()
			{
				System.out.println("情人");
			}
			public void show2()
			{
				System.out.println("海阔天空");
			}
		});
		System.out.println("---------");
		new TangYi().show();
	}
	public static void show(Inter in)
	{
		in.show1();
		in.show2();
	}
}