java基础_05_内部类

内部类

内部类是指在一个外部类的内部再定义一个类，可用protected和private 修饰。而外部类只能使用public和缺省的包访问权限。

注意：内部类只是一个编译时期的概念，一量编译成功，就会成为完全不同的两类。

特点：

1，内部类可以直接访问外部类的东西

2，外部类要访问内部类的东西要先建立对象

为什么需要内部类？

内部类继承自某个类或实现某个接口，内部类的代码操作创建其外围类的对象，所以可以认为内部类提供了某种进入其外围类的方法。

好处：每个内部类都能独立的去继承实现接口，所以无论外围类是否已经继承了某个实现，对于内部类都没有影响，内部类有效的实现了“多重继承”。

内部类可以分为4种：

1，静态内部类

使用static 修饰，声明在外部类的类体中。静态内部类中可以访问外部类的静态成员。

如果你不需要内部类与其外围类之间有联系，那么可以声明为satic。

2，成员内部类

一，声明在外部类的类体中，不使用static 修饰，具有类的成员特征，必须有类的实例才会创建内部类实例。

二，内部类实例可以访问共享外部类的成员变量。

3，局部内部类

把类声明在方法中，类似局部变量。（很少见）

例：

　　void fanfa(){
　　		final int a=3;  //这里加final 下面这个局部类才能访问
　　
　　		class Demoin{
　　			void display(){
　　				//注意局部里面的类要访问的变量必须是final 最终的
　　				System.out.println (a);
　　			}
　　		}
　　		new Demoin().display();
　　	}

4，匿名内部类（重点）

匿名类和内部类差不多，只是类名没体现出来。

1，匿名内部类其实就是内部类的简写格式

2，定义匿名内部类的前提：	内部类必须继承一个类或者实现接口

3，匿名内部类的格式：  new 父类或者接口（）｛定义子类的内容｝

4，其实匿名内部类就是一个匿名子类对象。可以理解为带内容的对象

5,  匿名内部类中定义的方法最好不要超过3个。

6，匿名类，非常常见，可以写在任何地方，就像一般的语句。

7，匿名类是对原类的一个继承，同时创建了实例，｛｝就是继承以后的类体，类体中可以使用所有类的语法。

8，匿名类不能写构造器。

9，匿名类可以从抽象类或者接口继承。

10，匿名内部类不能定义任何静态成员、方法和类。

11，匿名内部类不能是public, protected, private, staic .

12，匿名类只能创建其自身那一个实例。

那些地方使用匿名内部类呢？

1，只用到类的一个实例。

2，类在定义后马上用到。

心得：内部类就是类体里面在建立一个类，这个内部类可以去继承其它类，或实现接口。提供了访问外围类的路径，把	  类的单继承进行了改善。其中匿名类是重点，在使用中应用最多。内部类可以访问外围类的资源，要注意它们的  

      写法。

例一：
　　abstract class Demo
　　{
　　	abstract void show();
　　}
　　class Out
　　{
　　	int x = 3;
　　//	class In extends Demo
　　//	{
　　//		void show(){
　　//			System.out.println("show.."+x);
　　//		}
　　//	}
　　
　　	void dis()
　　	{
　　//		In in=new In();
　　//		in.show();
　　
　　
　　//匿名类使用方法，上面的内部类使用可以用下面匿名类来实现，少写代码
　　		new Demo()
　　		{
　　			void show(){ //覆盖
　　				System.out.println("show.."+x);
　　			}
　　		}.show();
　　
　　
　　//也可以给上面这个对象取名，如下：功能一样
　　	//	Demo d=new Demo()
　　	//	{
　　	//		void show(){ //覆盖
　　	//			System.out.println("show.."+x);
　　	//		}
　　	//	};
　　	//	d.show();
　　	}
　　}
　　class  OutIn
　　{
　　	public static void main(String[] args) 
　　	{
　　		Out out=new Out();
　　		out.dis();
　　	}
　　}
　　
例二：
　　class Out
　　{
　　	private int x=3;
　　	class In
　　	{
　　		int x=4;
　　		void function(){
　　			int x=6;
　　
　　			//访问x=6 直接写x
　　			//访问x=4 写this.x
　　			//访问外部类x=3  得写成 Out.this.x
　　			//如果内部类里和方法里没有定义x 直接访问外部类的x
　　			System.out.println("In.."+Out.this.x);
　　		}
　　	}
　　
　　	void show(){
　　		System.out.println(x);
　　		//访问内部类,得先建立对象
　　		In in=new In();
　　		in.function();
　　	}
　　	
　　	//局部类使用
　　	void fanfa(){
　　		final int a=3;  //这里加final 下面这个局部类才能访问
　　		class Demoin{
　　			void display(){
　　			//注意局部里面的类要访问的变量必须是final 最终的
　　			System.out.println (a);
　　			}
　　		}
　　		new Demoin().display();
　　	}
　　
　　}
　　class  OutIn
　　{
　　	public static void main(String[] args) 
　　	{
　　		Out out=new Out();
　　		out.show();
　　		//直接建立内部类,用下面方式（内部类必须是非静态的）
　　		Out.In oi=new Out().new In();
　　		oi.function();
　　	}
　　}