黑马程序员—内部类

   ------- android培训、java培训、期待与您交流！ ----------

＝＝＝＝＝＝＝内部类＝＝＝＝＝＝＝

定义在其他代码块（类体或者方法体）里的类称为内部类；

编译后每一个内部类都会有自己的独立的字节码文件，

文件名：Outer$Inner.class－－＞内部类也可以有父类和实现接口。也可以有抽象方法。

 

根本位置和修饰符的不同分为四种：

1，member innerclass       成员内部类，当实例方法或变量一样理解。

      1）定义的位置：类以内，方法之外，没有静态修饰符（static）。

      2）本身能定义的属性和方法：只能定义非静态的属性和方法。

      3）能直接访问的什么：能访问外部类的所有静态和非静态的属性或方法。

      4）怎么创建对象：在外部类内的方法内：Outer.Inner inner=newOuter().new Inner();

         在外部类外的类的方法内：Outer.Inner inner=new Outer().new Inner();或在Outer类里提供一个getInner()方法,

         返回内部类的对象，这样在外部类外的类的方法内也可以用该成员内部类。

       实例程序：

      

//成员内部类
class MemberInner
{
	private int a = 4;
	
	public class Inner2
	{
		private int a = 5;//就近原则
		
		public void doSomething()
		{
			System.out.println(MemberInner.this.a);//在同名的情况下，使用外部成员变量
		}
	}
	public void method()
	{
		Inner2 inner = this.new Inner2();
	}
}

public class MemberInnerClassTest
{
	public static void main(String[] args)
	{								//外部类的实例,内部类的实例
		MemberInner.Inner2 inner = (new MemberInner()).new Inner2();//内部类对象
		inner.doSomething();		
	}
}

     

2，static innerclass 静态内部类（嵌套内部类），当静态方法或变量一样理解。

      static只能修饰内部类，不能修饰外部类。

      1）定义的位置：类以内，方法之外，有静态修饰符（static）。一般写在外部类的属性下面。

      2）本身能定义的属性和方法：可以定义静态和非静态的属性或方法。

      3）能直接访问的什么：只能访问外部类的静态属性和方法。

      4）怎么创建对象：在外部类内的方法里： Outer.Inner inner=new Outer.Inner();

         在外部类外的类方法里：   Outer.Inner inner=newOuter.Inner();

      实例程序:

     

class StaticInner
{ 
	private static int a = 4;
	public static class Inner
	{
		public void test()
		{
			System.out.println(a);
		}
	}
}
public class StaticInnerClassTest
{
	public static void main(String[] args)
	{
		StaticInner.Inner inner = new StaticInner.Inner();
		
		inner.test();
	}
}

3，local innerclass        局部内部类           当局部变量一样理解，只能方法本身内使用。

      1）定义的位置：方法里面的类，前面不能用public或static修饰。

      2）本身能定义的属性和方法：只能定义非静态的属性和方法。

      3）能直接访问的什么：能访问方法内用final修饰的局部变量（不能与该类内的变量名相同）。

                                       能访问外部类的所有静态和非静态的属性或方法。

      4）怎么创建对象：只能在方法内创建对象，如：Inner inner=newInner(); 对象的作用范围只在方法内。

        实例程序：

       

//局部内部类
//能访问方法内用final修饰的局部变量（不能与该类内的变量名相同）。
//能访问外部类的所有静态和非静态的属性或方法。
class LocalInner
{
	int a = 10;//static
	public void doSomething()
	{
		final int a = 4;
		//注意访问修饰符
		class Inner3
		{
			public void test()
			{
				System.out.println("inner : "+a);
				//方法外部的成员变量
				System.out.println("outer : "+LocalInner.this.a);
				LocalInner.this.doMethod();//非静态方法
				LocalInner.doMethod2();//静态方法

			}
		}
		new Inner3().test();
	}
	public void doMethod()
	{
		System.out.println("Local Inner class Test...");
	}
	public static void doMethod2()
	{
		System.out.println("Local Inner class Test2...");
	}
}
public class LocalInnerClassTest
{
	public static void main(String[] args)
	{
		LocalInner localInner = new LocalInner();
		
		localInner.doSomething();
	}
}

4，annonymous innerclass         匿名内部类                     

      1）没有名字的类，没有构造方法。是一个特殊的局部内部类，         

             可以实现一个接口，或者一个类，                      

             生命周期里只能产生一个对象(xx)，也就是说只能被一个对象（xx）调用，

      2）除了没有名字外，看匿名内部类所在的位置，他的定义和访问将和成员内部类、静态内部类、局部内部类一样。

            一般像局部内部类的定义和访问比较多。

      3）当试图创建接口或者抽象类对象的时候，用匿名内部类。

           表示类体的{...}紧跟在抽象实例（接口）之后，表示实现该抽象实例（接口）。

           调用匿名内部类的方法只能用写类时创建的那个对象（tc）。

     作用：1，不破坏访问权限的情况下，内部类可以使用外部类的私有成员变量和方法。

           2，将接口公开，将实现类（实现公开的接口）作成内部类隐藏起来，强制要求使用者使用接口，强制降低偶合度。

           3，Java通过接口和内部类两种机制来实现多继承。在类内部可以建立本类的实例，然后调用本类内的其他方法。

    实例程序：

           

import java.util.Date;
/*匿名内部类会隐式地继承一个父类或实现一个接口*/
public class AnonymousInnerClassTest
{
	@SuppressWarnings("deprecation")
	public String get(Date date)
	{
		return date.toLocaleString();
	} 
	public static void main(String[] args)
	{
		AnonymousInnerClassTest test = new AnonymousInnerClassTest();
		//String str = test.get(new Date());;
		//System.out.println(str);
		
		String str = test.get(new Date()//匿名内部类
		{ 
			public String toLocaleString()
			{
				return "hello world";
			}
		});
		System.out.println(str);
	}
}

     -------  android培训 、 java培训、期待与您交流！ ----------