java内部类详解

一.内部类基础

 在java中,可以将一个类定义在另一个类里面或者一个方法里面,这样的类称为内部类,广泛意义上的内部类一般来说包括这四种:成员内部类,局部内部类,匿名内部类和几台内部类.下面就先来了解一下这四种内部类的用法.

1.成员内部类

   成员内部类是最普通的内部类,它定义为位于另一个类的内部,形式如下:

class Cicle {

  double radius = 0;

  public Circle(double raius) {

      this.radius = radius;

  }

   class Draw {  //内部类

    public  void drawShape(){

         System.out.println("drawshape");

     }

   }

}

这样看起来,类Draw像是类Cricle的一个成员,Circle称为外部类.成员内部类可以无条件访问内部类的所有成员方法(包括private成员和静态成员).

class Circle {
	private double radius = 0;
	public static int count =1;
	public Circle(double radius) {
		this.radius = radius;
	}
	
	class Draw {     //内部类
		public void drawSahpe() {
			System.out.println(radius);  //外部类的private成员
			System.out.println(count);   //外部类的静态成员
		}
	}
}

不过要注意的是,当成员内部类拥有和外部内同名的成员变量或则方法时,会发生隐藏现象,即默认情况下访问的是成员变量.如果要访问外部内的同名成员,需要以下面的形式进行访问:

外部类.this.成员变量

外部内.this.成员方法

  虽然成员内部内可以无条件地访问外部内的成员,而外部类想要访问成员内部类的成员却不是这么随心所欲了.在外部类中如果要访问成员内部类的成员,必须先创建一个成员内部类的对象,在通过指向这个对象的引用来访问:

class Circle {
	private double radius = 0;

	public Circle(double radius) {
		this.radius = radius;
		getDrawInstance().drawSahpe();   //必须先创建成员内部类的对象，再进行访问
	}
	
	private Draw getDrawInstance() {
		return new Draw();
	}
	
	class Draw {     //内部类
		public void drawSahpe() {
			System.out.println(radius);  //外部类的private成员
		}
	}
}

成员内部类是依附外部内而存在的,也就是说,如果要创建成员内部类的对象,前提是必须存在一个外部类的对象.创建成员内部类的一般形式如下:

public class Test {
	public static void main(String[] args)  {
		//第一种方式：
		Outter outter = new Outter();
		Outter.Inner inner = outter.new Inner();  //必须通过Outter对象来创建
		
		//第二种方式：
		Outter.Inner inner1 = outter.getInnerInstance();
	}
}

class Outter {
	private Inner inner = null;
	public Outter() {
		
	}
	
	public Inner getInnerInstance() {
		if(inner == null)
			inner = new Inner();
		return inner;
	}
	 

class Inner {
		public Inner() {
			
		}
	}
}

内部类可以拥有private访问权限,protected访问权限,public访问权限及包访问权限,比如上面的例子,如果成员内部类Inner用private

修饰,则只能在外部类的内部访问,如果用public修饰,则任何地方都要访问;如果用protected修饰,则只是在同一个包下,或者外部类

的情况下访问;如果是默认访问权限,则只能在同一个包下访问.这一点和外部内有一点不一样,外部类只能被public 和包访问.我个人是这样理解的,由于成员外部类看起来像是外部类的一个成员,所以可以像类的成员一样拥有多种权限修饰

 

2.局部内部类

局部内部类是定义在一个方法或者一个作用于里面的类,它和成员内部类的区别在于局部内部类的访问权限仅限于方法内或者该作用域内.

class People{
	public People() {
		
	}
}

class Man{
	public Man(){
		
	}
	
	public People getWoman(){
		class Woman extends People{   //局部内部类
			int age =0;
		}
		return new Woman();
	}
}

注意,局部内部类就像是方法里面的一个局部变量一样,是不能有 public .protected.private以及static修饰的.

3.匿名内部类

匿名内部类应该是平时我们编写代码时用的最多的,在编写事件监听的代码时使用匿名内部类不但方便,而且是代码更加容易维护.

下面这段代码是一个android事件监听代码:

scan_bt.setOnClickListener(new OnClickListener() {
			
			@Override
			public void onClick(View v) {
				// TODO Auto-generated method stub
				
			}
		});
    	
    	history_bt.setOnClickListener(new OnClickListener() {
			
			@Override
			public void onClick(View v) {
				// TODO Auto-generated method stub
				
			}
		});

这段代码为两个按钮设置监听器，这里面就使用了匿名内部类。这段代码中的：

new OnClickListener() {
			
			@Override
			public void onClick(View v) {
				// TODO Auto-generated method stub
				
			}
		}

就是匿名内部类的使用.代码中需要给按钮设置监听对象,使用匿名内部类能够在实现父类或者接口中的方法情况下同时产生一个相应的对象,但是前提是这个父类或者借口下存在才能这样使用.当然想下面这种写法也是可以的,跟上面使用匿名内部类达到效果相同

private void setListener()
{
    scan_bt.setOnClickListener(new Listener1());    	
    history_bt.setOnClickListener(new Listener2());
}

class Listener1 implements View.OnClickListener{
    @Override
    public void onClick(View v) {
    // TODO Auto-generated method stub
			
    }
}

class Listener2 implements View.OnClickListener{
    @Override
    public void onClick(View v) {
    // TODO Auto-generated method stub
			
    }
}

 

 

这种写法虽然能达到一样的效果,但是既冗长又难以维护,所以一般使用匿名内部类的方法来编写事件监听代码.同样的,匿名内部类也是不能访问修饰符和static修饰符的.

匿名内部类是唯一一种没有构造器的类.正因为其没有构造器,所以匿名内部类的使用范围非常有限,大部分匿名内部类用于接口回调.匿名内部类在编译的时候有系统自动起名为outer.$1.class.一般来说,匿名内部类用于继承其他类或是实现接口,并不需要添加额外的方法,只是对继承方法的实现或是重写.

4.静态内部类也是定义在另一个类里面的类,只不过类的前面多一个关键字static,静态内部类是不需要依附于外部类的,这点和类的静态成员属性类似,并且他不能使用外部类的非static成员变量或者是方法,这一点很好理解,因为在没有外部内的对昂情况下,可以创建静态内部类的对象,如果允许访问外部类的非static成员就会产生矛盾,因为外部类的非static成员必须依附于具体的对象.

public class Test {
	public static void main(String[] args)  {
		Outter.Inner inner = new Outter.Inner();
	}
}

class Outter {
	public Outter() {
		
	}
	
	static class Inner {
		public Inner() {
			
		}
	}
}

二.深入理解内部类

1. 为什么成员内部类可以无条件访问外部类的成员?

在此之前,我们已经讨论了成员内部类可以无条件访问外部类的成员,那具体究竟是如何实现的呢?下面通过反编译字节码文件看看究竟.事实上,编译器在进行编译的时候呀,会将成员内部类单独编译一个字节码文件,下面是Outter.java的代码:

public class Outter {
	private Inner inner = null;
	public Outter() {
		
	}
	
	public Inner getInnerInstance() {
		if(inner == null)
			inner = new Inner();
		return inner;
	}
	 
	protected class Inner {
		public Inner() {
			
		}
	}
}

虽然我们在定义的内部类的构造器是无参构造器，编译器还是会默认添加一个参数，该参数的类型为指向外部类对象的一个引用，所以成员内部类中的Outter this&0 指针便指向了外部类对象，因此可以在成员内部类中随意访问外部类的成员。从这里也间接说明了成员内部类是依赖于外部类的，如果没有创建外部类的对象，则无法对Outter this&0引用进行初始化赋值，也就无法创建成员内部类的对象了。