内部类详解

一、内部类概述

   定义在类体部，方法体部，甚至比方法体更小的代码块内部的类。比如：在类A中定义了一个类B，类B就是内部类。

1、内部类的访问特点：

a、内部类可以直接访问外部类的所有成员，包括私有

b、外部类要访问内部类的成员，必须创建对象

2、内部类的位置：

a、成员位置：在类体部，方法体外。被称为成员内部类

b、局部位置：定义在方法体，甚至比方法体更小的代码块。被称为局部内部类

二、成员内部类

1、成员内部类无修饰符修饰,如何直接访问内部类的成员？

格式：外部类名.内部类名 对象名=new 外部类名().new 内部类名();

package test.innerclass;
/**
 * @author Nocol
 *
 * @TODO
 * 
 */
class Outer {
	private  int num = 100;

	 class Inner {               //此时该内部类无任何修饰符修饰
		public  void show() {
			System.out.println(num);    //内部类直接访问外部类私有成员
		}
	}
}

class InnerClassDemo {
	public static void main(String[] args) {
		// 需求：访问Inner类的show()方法
		// Inner i = new Inner(); 报错
		// i.show();报错

		// 格式：外部类名.内部类名 对象名 = 外部类对象.内部类对象;
		Outer.Inner oi = new Outer().new Inner();
		oi.show();
	}
}

2、成员内部类被private修饰，如何访问该私有内部类的方法？

方法：成员内部类可以看成是外部类的一个成员变量，所以外部类的方法里面可以直接拿内部类创建其对象并使用。因此，我们可以在外部类写一个方法，在这个方法内创建内部类的对象（相当于一个类里面的方法使用成员变量），并用该对象调用私有内部类的方法

package test.innerclass;

/**
 * @author Nocol
 *
 * @TODO
 * 
 */
class Outer1 {
	private int num = 200;

	 private class Inner {         //内部类被Private修饰
		public void show() {
			System.out.println(num);//内部类直接访问外部类私有成员
		}
	}
	public void method() {
		// 找不到符号
		// show();
		Inner i = new Inner();//创建内部类对象，测试时可通过创建外部类Outer对象调用method()方法从而实现对内部类中定义的私有方法的调用
		i.show();
	}
}
class InnerClassDemo2 {
	public static void main(String[] args) {
      //测试
	  //需求：访问被privaet修饰的Inner类的show()方法
		Outer1 o=new Outer1();
		o.method();   //打印10
	}
}

3、成员内部类被static修饰，如何访问内部类的成员？

格式：外部类名.内部类名 对象名 =new 外部类名.内部类名();

需要注意的一点：

静态内部类访问的 外部类数据必须用静态修饰。

比如：静态内部类的静态方法和非静态方法在访问成员变量时，该成员变量必须由static修饰

package test.innerclass;
/**
* @author Nocol
*
* @TODO 
* 
*/
class Outer3{
      //private  int num=300;     //非静态
      private static int num2=400;   //静态
      
    //内部类用静态修饰是因为内部类可以看出是外部类的成员
      public static class Inner{
    	  
    	  /**
    	   * 静态内部类的普通方法
    	   */
    	  public void show(){
    		 // System.out.println(num); 报错， 静态内部类的方法（非静态）访问的 外部类成员变量必须是static静态修饰的。
    		  System.out.println(num2);  
    	  }
    	  
    	  /**
    	   * 静态内部类的静态方法
    	   */
    	  public static void show2(){
    		 //System.out.println(num); 报错
    		  System.out.println(num2);//静态方法访问静态成员变量
    	  }
    	      	  
      }
}
public class InnerClassDemo3 {
	public static void main(String[] args){
		        //使用内部类
				//Outer3.Inner oi = new Outer().new Inner();  报错，限定的新静态类
				//oi.show();
				//oi.show2();
				
				//成员内部类被静态修饰后的访问方式是:
				//格式：外部类名.内部类名 对象名 = new 外部类名.内部类名();
		
				Outer3.Inner oi = new Outer3.Inner();
				oi.show();   //400
				oi.show2();  //400   //Inner.show2();
				
				//show2()的另一种调用方式
				//由于内部类被static静态修饰，可直接【类名.方法名调用】
				Outer3.Inner.show2(); //外部类Outer3下的Inner内部类
		
	}
}

三、局部内部类

1、定义在方法体内。可以访问外部类的成员，包括私有。

2、外部怎么调用方法内内部类里面的方法？
 
可以在该方法内创建局部内部类的对象，通过对象调用内部类的方法。

3、需要注意的几点：

a、若局部内部类定义在非静态的方法体内：
 
   局部内部类可以访问外部类的所有成员。包括私有、包括（非）静态成员变量、（非）静态方法

b、若局部内部类定义在静态的方法体内：

   局部内部类只能访问外部类的静态成员。包括私有、静态成员变量、静态方法

c、若局部内部类访问方法体内的局部变量：
    
   该局部变量必须由final修饰。

原因：局部变量是随着方法的调用而调用，随着调用完毕而消失。 而堆内存的内容并不会立即消失。所以，我们加final修饰。加入final修饰后，这个变量就成了常量。既然是常量。你消失了。 我在内存中存储的是真实的数据，所以，我还是有数据在使用。

package test.innerclass;

/**
 * @author Nocol
 *
 * @TODO
 * 
 */
class Outer4 {
	
	private  int num = 10;
     
	/**
	 * 局部内部类定义在非静态方法体内
	 */
	public void method() {
		// int num = 20;             
	    final int num2 = 20;         //若要被局部内部类访问，该局部内部类的局部变量必须用final修饰
	    
		class Inner {                //局部内部类
			public void show() {
				System.out.println(num);    //访问的 成员变量 不需要被final修饰
				
				System.out.println(num2);  //20 //从内部类中访问本地变量(局部变量)num2; 需要被声明为最终类型
				
				test();  //非静态方法中的内部类访问外部类的静态方法（同样可以访问外部类的非静态方法）
			}
		}
		
		Inner i = new Inner();   //在局部 内部类外 创建其对象，方便实现对内部类内方法的调用
		i.show();
		
	}
	public static void test(){
		System.out.println("我是静态方法");
	}
}
class InnerClassDemo4 {
	public static void main(String[] args) {
		Outer4 o = new Outer4();
		o.method();
	}
}

四、匿名内部类

1、匿名内部类即局部内部类的一种，其实就是内部类的简化写法。

2、前提：存在一个类或者是接口。（这里的类可以是具体类也可以是抽象类）

3、格式：new 类名或接口名(){ 重写方法;},该整体就是一个对象，本质就是继承了该类或实现了该接口的子类匿名对象

package test.innerclass;
/**
 * @author Nocol
 *
 * @TODO
 * 
 */
interface Person {
	public abstract void study();
}

class PersonDemo {
	
	public void method(Person p) {// 接口名作为形式参数,其实这里需要的不是接口，而是该接口的实现类的对象
	                     
		p.study();
	}
}

// 定义接口实现类
class Student implements Person {
	public void study() {
		System.out.println("study");
	}
}

class InnerClassDemo6 {
	public static void main(String[] args) {
		// 测试
		PersonDemo pd = new PersonDemo();
		Person p = new Student();
		pd.method(p);
		System.out.println("-------------------------");

		// 匿名内部类在开发中的使用
		// 匿名内部类的本质是 继承类或者实现了接口的子类匿名对象，所以讲该整体对象当做抽象类Person的子类对象传进去
		                                                         //相当于：new Student();
		pd.method(new Person() {
			public void study() {
				System.out.println("study");
			}
		});
	}
}

五、关于内部类的两道面试题

1、内部类访问问题。

package test.innerclass;

/**
 * @author Nocol
 *
 * @TODO
/*
 * 面试题： 要求请填空分别输出30，20，10。
 * 
 * 注意： 
 *     1:内部类和外部类没有继承关系。
 *     2:通过外部类名限定this对象 Outer.this
 */
class Outer5 {
	public int num = 10;
	class Inner {                  //成员内部类
		public int num = 20;

		public void show() {
			int num = 30;
			
			System.out.println(num);
			System.out.println(this.num);             //this表示本类的num
		   // System.out.println(new Outer5().num);      //也可以
			System.out.println(Outer5.this.num);      //Outer5.this 表示是外部类的东西
		} 
	}
}
class InnerClassTest {
	public static void main(String[] args) {
		Outer5.Inner oi = new Outer5().new Inner();
		oi.show();
	}
}

2、分析题

package test.innerclass;

/**
 * @author Nocol
 *
 * @TODO
 * 
 */
/*  
 * 匿名内部类面试题： 按照要求，补齐代码 
 *             
 * interface Inter1 { 
 * 		void show();               //默认 public abstract void show();
 * } 
 * class Outer7 { //补齐代码 }
 * 
 * class OuterTest2 { 
 * 		public static void main(String[] args) {
 *           	Outer7.method().show(); 
 *        } 
 *   } 
 *   
 *   要求在控制台输出”HelloWorld”
 */
interface Inter1 {
	void show();
	// public abstract
}

class Outer7 {
	// 补齐代码
	public static Inter1 method() {     //接口作为返回值，实际返回该接口实现类的对象，刚好就是匿名内部类
		// 子类对象 -- 子类匿名对象
		return new Inter1() {
			public void show() {
				System.out.println("HelloWorld");
			}
		};
	}
}

class OuterTest2 {
	public static void main(String[] args) {
		Outer7.method().show();
		/*
		 * 1:Outer7.method()可以看出method()应该是Outer中的一个 静态方法。
		 * 2:Outer7.method().show()可以看出method()方法的返回值是一个对象。
		 * 又由于接口Inter1中有一个show()方法,所以我认为method()方法的返回值类型是一个接口。
		 */
	}
}