面向对象5_【内部类】

内部类定义

一个类定义在另一个类里面,编译后会产生一个Outer$Inner.class文件

内部类访问特点：

1，内部类可以直接访问外部类中的成员。

2，外部类要访问内部类，必须建立内部类的对象。

一般用于类的设计。(优化代码设计)

分析事物时，发现该事物描述中还有事物，而且这个事物还在访问被描述事物的内容。

这时就把还有的事物定义成内部类来描述。（例如人体>心脏）

内部类可以写在外部类的任意位置上（成员、局部）

如果内部类定义了静态成员，该内部类必须被静态修饰

格式：
class Outer
{	//如果内部类是静态的引用了外部类的成员，该成员必须是静态的，否则会跳出异常
	private static int num =3;
	//private class Inner	//内部类一般都会被封装起来private，通过共有方法（制定访问规则）访问
	static class Inner		//
　　{
　　void show()
　　{
　　	System.out.println(“show run….”+num);
　　}
　　/*static void function()//如果内部类中定义了静态成员，该内部类也必须是静态的。
		{				//当外部类中静态方法访问内部类时，内部类也必须是static的
			System.out.println("function run ...."+num);
　　	}*/
　　}
　　public void method()
　　{
　　	Inner in= new Inner();	//外部类要访问内部类，必须建立内部类的对象。
　　	in.show();
　　}
}
class InnerClassDemo
{
	public static void main(String[] args) 
	{
		Outer out=new Outer();
		Outer.method();
		//直接访问外部类中的内部类 成员
		Outer.Inner in= new Outer().new Inner();//必须声明所属
		in.show();
		// 如果内部类是静态的，相当于一个外部类,(随着外部类的加载而存在)
		Outer.Inner in =new Outer.Inner();
		in,.show();
		//如果内部类和其成员都是静态的，可以不创建对象直接调用
		Outer.Inner.fuction();
　　}
}

为什么内部类能直接访问外部类中成员呢？

那是因为内部类持有了外部类的引用。  外部类名.this

 

局部内部类

访问规则不变,不能被static修饰

class Outer
{void method()
{
	final int x =9;//从内部类中访问局部变量x需要被声明为最终类型
	class Inner
	{
		void show()
		{
			System.out.println(num);
　　}
　　}
}}



/*
内部类可以存放在局部位置上。 
内部类在局部位置上只能访问局部中被final修饰的局部变量。(即常量)
*/
class Outer
{
	int num = 3;
	Object method()
	{
		final int x = 9;
		class Inner
		{
			public String toString()
			{
				return "show ..."+x;
			}
		}
		Object in = new Inner();//局部内部类只能在局部创建对象
		return in;//0x0045
//		in.show();
	}
}

class InnerClassDemo3 
{
	public static void main(String[] args) 
	{
		Outer out = new Outer();
		Object obj = out.method();
		System.out.println(obj);
	}
}

匿名内部类

内部类的简写格式，

必须有前提：

内部类必须继承或者实现一个外部类或者接口。

匿名内部类：其实就是一个匿名子类对象。 

格式： new 父类or接口(){子类内容}

 

要注意:创建时都会自动类型提升为父类/接口的类型，

单次使用时（胖对象.方法）可以访问子类特有内容

多次引用时会自动类型提升为父类/接口的类型，就无法访问子类的特有内容

*/

abstract class Demo
{
	abstract void show();
}

class Outer
{
	int num = 4;
	/*
	class Inner extends Demo	//正常步骤
	{
		void show()
		{
			System.out.println("show ..."+num);
		}
	}
	*/
	public void method()
	{
		//new Inner().show();//匿名对象
		new Demo()//匿名内部类。无Inner,创建了一个Demo类的子类对象
		{
			void show()//有内容的对象，show() 复写父类方法
			{
				System.out.println("show ........"+num);
			}
		}.show();//匿名 子类对象调用父类成员,父类方法被子类覆盖
	}
}
class InnerClassDemo4 
{
	public static void main(String[] args) 
	{
		new Outer().method();
	}
}

内部类的应用

interface Inter
{
	void show1();
	void show2();
}

class Outer
{
	/*
	class Inner implements Inter
	{
		public void show1()
		{
		}
		public void show2()
		{
		}
	}
	*/

	public void method()
	{
//		Inner in = new Inner();
//		in.show1();
//		in.show2();
		
		Inter in = new Inter()
		{
			public void show1()
			{
			}
			public void show2()
			{			
			}			
		};
		in.show1();//接口类型的对象,方法被子类实现
		in.show2();
	}
}

　　//小练习
		//Test.function():Test类中有一个静态的方法function。
		//.method():function这个方法运算后的结果是一个对象。而且是一个Inter类型的对象。
		//因为只有是Inter类型的对象，才可以调用method方法。
　　	Test.function().method();
/*

通常的使用场景之一：

当函数参数是接口类型时，而且接口中的方法不超过三个。

可以用匿名内部类作为实际参数进行传递

*/

class InnerClassDemo5 
{

	class Inner
	{
	}
	public static void main(String[] args) 
	{
		/*
		show(new Inter()
		{
			public void show1(){}
			public void show2(){}
		});	//匿名内部类在方法的参数列表,作为一个参数来传递
		*/

//		new Inner();
	}

	public void method()
	{
		new Inner();
	}

	public static void show(Inter in)
	{
		in.show1();
		in.show2();
	}
}

面试题（匿名内部类的多态性）

class Outer
{
	void method()
	{
		Object obj = new Object()
		{
			public void show()
			{
				System.out.println("show run");
			}
		};	为什么 .show可以，分开就不行
		obj.show();//	因为匿名内部类这个子类对象被向上转型为了Object类型。
					//这样就不能在使用子类特有的方法了。
	}
}
class InnerClassDemo6 
{
	public static void main(String[] args) 
	{
		new Outer().method();
	}
}