内部类不是很好理解,但说白了其实也就是一个类中还包含着另外一个类

如同一个人是由大脑、肢体、器官等身体结果组成,而内部类相当于其中的某个器官之一,例如心脏:它也有自己的属性和行为(血液、跳动)

显然,此处不能单方面用属性或者方法表示一个心脏,而需要一个类

而心脏又在人体当中,正如同是内部类在外部内当中

java内部类分为: 成员内部类、静态嵌套类、方法内部类、匿名内部类 。

1内部类的共性

(1)、内部类仍然是一个独立的类,在编译之后内部类会被编译成独立的.class文件,但是前面冠以外部类的类名和$符号 。

(2)、内部类不能用普通的方式访问。内部类是外部类的一个成员,因此内部类可以自由地访问外部类的成员变量,无论是否是private的 。


(3)、内部类声明成静态的,就不能随便的访问外部类的成员变量了,此时内部类只能访问外部类的静态成员变量 。


1内部类的作用

内部类其实严重破坏了良好的代码结构,但为什么还要使用内部类呢?

因为内部类可以随意使用外部类的成员变量(包括私有)而不用生成外部类的对象,这也是内部类的唯一优点

如同心脏可以直接访问身体的血液,而不是通过医生来抽血。为了加深对Java内部类的理解,多想想内部类与外部类之间怎么转换的写法,我们可以体会出,写内部类会方便很多。



1内部类实例

package 内部类异常包装器;
/**
 * 
 * TODO 成员内部类
 *
 * @author qiqitrue
 * @version 1.0 
 * @since 2014-6-16
 */
public class MemberOuter {
	private static int i;//静态成员变量
	private int j = 10;
	private int k =20;
	
	public static void outer_f1(){
		System.out.println("内部使用外部outer_f1()方法");
	}//定义一个外部的静态方法

	public void outer_f2(){
		System.out.println("内部使用外部outer_f2()方法");
	}
	
	class Inner{
//		static int inner_i = 100;//内部不允许定义静态变量
		int j = 100;
		int inner_i =1;
		int k =10;
		void inner_f1(){//内部类与外部类方法重名
			System.out.println("可以直接访问外部类变量:  "+i);//得到初始值0
			System.out.println("在内部类中访问内部类的变量直接用变量名(也可以用this.j): "+j);
			
			System.out.println("内部类使用外部类中与同类同名的实例变量用外部名.this.变量名"+MemberOuter.this.j);
			System.out.println("内部类的k: "+k);//内部类变量
			System.out.println("内部取外部类用"+MemberOuter.this.k); //取外部类则要外部类.this.变量名
			outer_f1();//不需要外部类名.this
			outer_f2();
		}
		
	}
	public void outer_f3(){//外部类方法可以直接使用new对内部类的使用
		System.err.println("进入outer_f3来取内部类方法成员");
		Inner inner = new Inner();
		inner.inner_f1();
	}
	 
	public static void main(String[] args) {
		//MemberOuter.Inner in = new MemberOuter().new Inner();
		//in.inner_f1();
		//注释可写成
		MemberOuter m = new MemberOuter();
		m.outer_f3();
		
	}
}
package 内部类异常包装器;
/**
 * 
 * TODO 成员内部类
 *
 * @author qiqitrue
 * @version 1.0 
 * @since 2014-6-16
 */
public class MemberOuter {
	private static int i;//静态成员变量
	private int j = 10;
	private int k =20;
	
	public static void outer_f1(){
		System.out.println("内部使用外部outer_f1()方法");
	}//定义一个外部的静态方法

	public void outer_f2(){
		System.out.println("内部使用外部outer_f2()方法");
	}
	
	class Inner{
//		static int inner_i = 100;//内部不允许定义静态变量
		int j = 100;
		int inner_i =1;
		int k =10;
		void inner_f1(){//内部类与外部类方法重名
			System.out.println("可以直接访问外部类变量:  "+i);//得到初始值0
			System.out.println("在内部类中访问内部类的变量直接用变量名(也可以用this.j): "+j);
			
			System.out.println("内部类使用外部类中与同类同名的实例变量用外部名.this.变量名"+MemberOuter.this.j);
			System.out.println("内部类的k: "+k);//内部类变量
			System.out.println("内部取外部类用"+MemberOuter.this.k); //取外部类则要外部类.this.变量名
			outer_f1();//不需要外部类名.this
			outer_f2();
		}
		
	}
	public void outer_f3(){//外部类方法可以直接使用new对内部类的使用
		System.err.println("进入outer_f3来取内部类方法成员");
		Inner inner = new Inner();
		inner.inner_f1();
	}
	 
	public static void main(String[] args) {
		//MemberOuter.Inner in = new MemberOuter().new Inner();
		//in.inner_f1();
		//注释可写成
		MemberOuter m = new MemberOuter();
		m.outer_f3();
		
	}
}






package 内部类异常包装器;

/**
 * 
 * TODO 方法内部类:顾名思义,嵌套在方法里面的类
 *
 * @author qiqitrue
 * @version 1.0 
 * @since 2014-6-16
 */
public class Out { //Out到MemberOuter为非静态成员内部类 -- Outer6开始为局部内部类
	
	int i = 9;
	public static void main(String[] args) {
		new Out().new in().display();//外部类引用内部类方法  外部类实例.内部类实例.方法
	 }
	  class in{//内部类
		public void display(){
			System.out.println("内部类对this的引用(相当于一个外部类的引用): "+Out.this.i);//内部类调用.this.变量
		}
		 
	}
	
}
package 内部类异常包装器;

/**
 * 
 * TODO 方法内部类:顾名思义,嵌套在方法里面的类
 *
 * @author qiqitrue
 * @version 1.0 
 * @since 2014-6-16
 */
public class Out { //Out到MemberOuter为非静态成员内部类 -- Outer6开始为局部内部类
	
	int i = 9;
	public static void main(String[] args) {
		new Out().new in().display();//外部类引用内部类方法  外部类实例.内部类实例.方法
	 }
	  class in{//内部类
		public void display(){
			System.out.println("内部类对this的引用(相当于一个外部类的引用): "+Out.this.i);//内部类调用.this.变量
		}
		 
	}
	
}






package 内部类异常包装器;

/**
 * 
 * TODO 成员内部类2
 *
 * @author qiqitrue
 * @version 1.0 
 * @since 2014-6-16
 */
public class Outer1 {
	private String name = "张三";
	class Inner1{ //内部类
		public void displayInner1(){
			System.out.println(name+"非静态内部类Inner1的displayInner1方法,可以直接访问非静态外部类的私有属性name="+name);
		}
	}
	public static void main(String[] args) {
		new Outer1().new Inner1().displayInner1();//非静态内部类Inner1的displayInner1方法,可以直接访问非静态外部类的私有属性
		
	}
}
package 内部类异常包装器;

/**
 * 
 * TODO 成员内部类2
 *
 * @author qiqitrue
 * @version 1.0 
 * @since 2014-6-16
 */
public class Outer1 {
	private String name = "张三";
	class Inner1{ //内部类
		public void displayInner1(){
			System.out.println(name+"非静态内部类Inner1的displayInner1方法,可以直接访问非静态外部类的私有属性name="+name);
		}
	}
	public static void main(String[] args) {
		new Outer1().new Inner1().displayInner1();//非静态内部类Inner1的displayInner1方法,可以直接访问非静态外部类的私有属性
		
	}
}






package 内部类异常包装器;

public class Outer2 {
	public static void main(String[] args) {		
		new Outer2().new Inner2().display();//对内部的调用
	}
	class Inner2{
		private int age = 88;
		public void display(){
			System.out.println(age);//private私有在本类中可直接访问
			System.out.println(this.age);//也可以通过this来访问
		}
	}
}
package 内部类异常包装器;

public class Outer2 {
	public static void main(String[] args) {		
		new Outer2().new Inner2().display();//对内部的调用
	}
	class Inner2{
		private int age = 88;
		public void display(){
			System.out.println(age);//private私有在本类中可直接访问
			System.out.println(this.age);//也可以通过this来访问
		}
	}
}






package 内部类异常包装器;

public class Outer3 {
	private int age = 98;
	class Inner3{
		private int age = 88;
		public void display(){
			System.out.println("内部类age: "+this.age);//内部类的成员访问
			System.out.println("外部类age: "+Outer3.this.age);//内部使用外部类成员用外部类.this.成员
		}
	}
	public static void main(String args[]){
		new Outer3().new Inner3().display();
	}
}
package 内部类异常包装器;

public class Outer3 {
	private int age = 98;
	class Inner3{
		private int age = 88;
		public void display(){
			System.out.println("内部类age: "+this.age);//内部类的成员访问
			System.out.println("外部类age: "+Outer3.this.age);//内部使用外部类成员用外部类.this.成员
		}
	}
	public static void main(String args[]){
		new Outer3().new Inner3().display();
	}
}






package 内部类异常包装器;

public class Outer4 {
	private char sex ='女';
	class Inner4{
		public void accessOuter(){
			System.out.println(sex);
		}
	}
	public static void main(String args[]){
		//通过外部类对象的引用来访问内部类的对象  外部类名.内部类 实例对象 = new 外部类.new 内部类 
		Outer4.Inner4 in  = new Outer4().new Inner4();
		in.accessOuter();
	}
}
package 内部类异常包装器;

public class Outer4 {
	private char sex ='女';
	class Inner4{
		public void accessOuter(){
			System.out.println(sex);
		}
	}
	public static void main(String args[]){
		//通过外部类对象的引用来访问内部类的对象  外部类名.内部类 实例对象 = new 外部类.new 内部类 
		Outer4.Inner4 in  = new Outer4().new Inner4();
		in.accessOuter();
	}
}



package 内部类异常包装器;

public class Outer6 {
	private int size=10;
	public static void main(String[] args) {
		Outer6 o = new Outer6();
		o.display();
	}
	public void display(){
		class Inner6{
			private int size;
			public void doStuff(int size){//构造有参数的方法
				int a = size++;//传入的size
				int b = this.size++;//局部内部类成员,在本类中的private size初始值为0
				int c = Outer6.this.size++;//外部类成员
				System.out.println(a+"\t"+b+"\t"+c);				
			}
		}
		 new Inner6().doStuff(2);//对局部内部类的使用
		
	}
}
package 内部类异常包装器;

public class Outer6 {
	private int size=10;
	public static void main(String[] args) {
		Outer6 o = new Outer6();
		o.display();
	}
	public void display(){
		class Inner6{
			private int size;
			public void doStuff(int size){//构造有参数的方法
				int a = size++;//传入的size
				int b = this.size++;//局部内部类成员,在本类中的private size初始值为0
				int c = Outer6.this.size++;//外部类成员
				System.out.println(a+"\t"+b+"\t"+c);				
			}
		}
		 new Inner6().doStuff(2);//对局部内部类的使用
		
	}
}



package 内部类异常包装器;

public  class Outer7 {
	String str = new String("Bettween");//String类的方法 = String str = "Bettween";
	String str2 = "abc";
	public void amethod(final int iArgs){//局部内部类中访问外部类的局部变量,此变量必须是final修饰
		int it= 0;
		class Bicycle{
			public void sayHello(){
				System.out.println(str);//访问受静态static影响
				System.out.println(iArgs);
//				System.out.println(Outer7.this.it);
			}			
		}
		new Bicycle().sayHello();//在类的外部使用实例化来调用内部类的方法
	}
	public static void main(String[] args) {
		new Outer7().amethod(2);
	}
}
package 内部类异常包装器;

public  class Outer7 {
	String str = new String("Bettween");//String类的方法 = String str = "Bettween";
	String str2 = "abc";
	public void amethod(final int iArgs){//局部内部类中访问外部类的局部变量,此变量必须是final修饰
		int it= 0;
		class Bicycle{
			public void sayHello(){
				System.out.println(str);//访问受静态static影响
				System.out.println(iArgs);
//				System.out.println(Outer7.this.it);
			}			
		}
		new Bicycle().sayHello();//在类的外部使用实例化来调用内部类的方法
	}
	public static void main(String[] args) {
		new Outer7().amethod(2);
	}
}