内部类详解

一.内部类

1.定义：一个类定义在另外一个类的内部，那么该类就称作为内部类。

2.内部类的class文件名：

经过编译后，内部类的.class文件名为：外部类$内部类.  这样命名的好处：便于区分该class文件是属于哪个外部类的。(比如遇到存在同名内部类的情况)

3.内部类的类别：

内部类包括成员内部类和局部内部类；

4.成员内部类：

(1) 定义：成员内部类指的是这个类定义在成员的位置上；

(2) 成员内部类的应用场景：

我们在描述A事物的时候，发现描述的A事物内部还存在另外一个比较复杂的事物B的时候，而且这个比较复杂事物B还需要访问A事物的属性等数据，那么这时候我们就可以使用内部类描述B事物。也就是说，如果这个类需要访问另外一个类的很多属性的时候，这时候就可以使用内部类。比如： 人--->心脏；

class 人{
			
	血
	氧气
	等....

	class 心脏{
				
	}		

}

比如上述人与心脏的关系，心脏需要用血和氧气等数据。如果这个心脏类放到人的内部，这样心脏类就可以很方便的访问到人的血等数据，可以直接访问；如果把心脏放到人之外，这时候它需要依靠对象来访问这些数据，这时候就需要别人先把人这个对象传递给你，这时候你才能访问到这些数据，而此时再写心脏类就会变得很复杂。

(3) 成员内部类的好处：内部类可以直接访问外部类的所有成员；

(4) 成员内部类的访问方式：

①方式一：在外部类提供一个方法创建内部类的对象进行访问；

//外部类
class Outer{
	//成员变量
	int x = 100; // Outer.class文件被加载到内存的时候存在内存中。  静态的成员数据是不需要对象存在才能访问。
	//成员内部类
	class Inner{      	
		int i = 10;
		public void print(){
			System.out.println("这个是成员内部类的print方法！"+i);
		}
	}
	//在外部的方法中创建了内部类的对象，然后调用内部 方法。
	public void instance(){
		Inner inner = new Inner();
		inner.print();
	}
}

//其他类
class Demo1{
	public static void main(String[] args){
		Outer outer = new Outer();
		outer.instance();
	}
}

运行结果如下：

②方式二：在其他类直接创建内部类的对象。 

格式：外部类.内部类  变量名 = new 外部类().new 内部类();

//外部类
class Outer{
	//成员变量
	int x = 100; // Outer.class文件被加载到内存的时候存在内存中。  静态的成员数据是不需要对象存在才能访问。
	//成员内部类
	class Inner{      	
		int i = 10;
		public void print(){
			System.out.println("这个是成员内部类的print方法！"+i);
		}
	}
}

//其他类
class Demo1{
	public static void main(String[] args){
		//成员变量的x在创建outer对象的时候才存在于内存中，同样Inner和x是处于同一个位置的，
		//也就是说如果想对Inner可见，那必须先创建外部类的对象，
		//当new Outer();的时候，Inner就存在于内存中了，
		//这时就可以通过new Inner再创建对象，创建对象后需要变量去指向它。
		Outer.Inner inner = new Outer().new Inner();
		inner.print();
	}
}

运行结果如下图所示：

注意：如果是一个静态内部类，那么在其他类创建 的格式：外部类.内部类  变量名 = new 外部类.内部类();

//外部类
class Outer{
	//成员变量
	int x = 100; // Outer.class文件被加载到内存的时候存在内存中。  静态的成员数据是不需要对象存在才能访问。
	//成员内部类
	static class Inner{      	
		static int i = 10;//静态的成员数据是不需要对象存在就可以访问的
		public void print(){
			System.out.println("这个是成员内部类的print方法！"+i);
		}
	}
}

//其他类
class Demo1{
	public static void main(String[] args){
		//Inner为静态内部类，此时它不需要对象存在就存在于内存中。
		Outer.Inner inner = new Outer.Inner();
		inner.print();
	}
}

运行结果如下图所示：

(5) 成员内部类要注意的细节：

①如果外部类与内部类存在同名的成员变量时，在内部类中默认情况下是访问内部类的成员变量。

可以通过"外部类.this.成员变量名" 指定访问外部类的 成员。（this代表了这个函数的当前的调用者对象，实际上new Outer().new Inner();是创建了两个对象，此时this搞不清调用它的到底是哪一个对象，这时候就要使用Outer.this）
②私有的成员内部类只能在外部类提供一个方法创建内部类的对象进行访问，不能在其他类创建对象了。
（内部类也可以用private修饰，一旦成员内部类Inner私有起来，出了这个类Outer外部就不可见，大括号外面的类也就无法访问到Inner，此时用其他类就不能创建它的对象。这时只能是在外部类提供一个方法创建内部类的对象）
③成员内部类一旦出现了静态的成员，那么该类也必须 使用static修饰。
原因：如果成员变量的x使用static修饰，这个x是在外部类Outer.class文件被加载到内存的时候存在内存中。也就是说静态的成员数据是不需要对象存在就能访问的。如果成员内部类Inner没有使用static修饰，但是在这个类里面出现了静态的成员，这时候别人如果要访问i，（i是静态的，使用类名就可以访问，但是此时Inner是在Outer对象存在的时候才存在内存中的，如果这种写法是合法的，此时应该通过new Outer()此时Inner才存在，此时就是new Outer().Inner.x来访问，如果这样才能访问，就已经违背了静态的成员数据是不需要对象存在就能访问的，这句话了违背了之前设计静态数据的原则，因为这时候的静态数据是依赖于对象的，这时候就需要把内部类也改为静态的形式，此时Inner在Outer这个类一旦加载就存在内存中，这时候就可以使用Outer.Inner.i来访问）

5. 局部内部类：

(1) 定义：在一个类的方法内部定义另外一个类，那么另外一个类就称作为局部内部类。

(2) 局部内部类要注意的细节：

如果局部 内部类访问了一个局部变量，那么该局部变量必须使用final修饰。

原因：用final修饰的局部变量y在方法执行完毕之后就消失，方法执行完毕之后Inner对象inner并没有消失，还要等待垃圾回收器回收它才会消失，也就是说Inner对象的生命周期比局部变量y的生命周期要长。当test方法执行到大括号结束时y已经消失，而Inner对象没有消失，而且Inner对象里面还有print方法还在访问着y，这时候就会造成感觉y的生命周期已经被延长了。

(3) 实例：

class  Outer{
	String name= "外部类的name";
	public void test(){
		//局部变量
		final int y =100;  // 局部变量y在test方法执行完毕之后从内存中消失。
		//局部内部类：和局部变量一样只能在方法内部去使用，方法内部Inner可见
		class Inner{   
			int x = 10;
			public void print(){
				System.out.println("这个是局部内部类的print方法.."+y);//这里留下的y        //只不过是之前的一个复制品
			}	
		}
		Inner inner = new Inner();  //Inner对象的生命周期比局部变量y的生命周期要长。
		inner.print();
	}
}

class Demo1 {
	public static void main(String[] args) {
		Outer outer = new Outer();
		outer.test();
	}
}

运行结果如下图所示：

①存在的问题：
.
②解决方案：

当test方法执行完毕之后，那么局部变量y马上从内存中消失，而Inner对象在方法执行完毕的时候还没有从内存中消失，Inner对象的print方法还在访问着y变量，这时候的y变量已经消失了，那么就给人感觉y的生命周期已经被延长了，也就是给人一种这个方法执行完毕之后这个y并没有消失的感觉，这时候就违背了当初设计局部变量的原则（局部变量的原则是一旦出了作用域马上就消失）

 如果一个局部内部类访问一个局部变量的时候，那么就让该局部内部类访问这个局部变量的复制品（所谓的复制品就是两份是一模一样的才叫复制品，如何才能让两份一模一样，要让他一模一样就是说在中间的过程中不能对它进行修改，如果不想让别人修改就只能使用final进行修饰）。

(4) 注意：成员内部类和局部内部类在现实开发中用到的并不多，使用最多的是匿名内部类，安卓开发使用最多，匿名内部类是以后做开发中使用频率最高的一个。

二.匿名内部类：

1. 定义：没有类名的类就称作为匿名内部类；

2. 匿名内部类的好处：简化书写；

3. 匿名内部类的使用前提：必须存在继承或者实现关系才能使用；

4. 匿名内部类一般是用于实参；

5. 继承关系下的匿名内部类：

(1) 需求：在方法内部定义一个类继承Animal类，然后调用run方法和sleep方法；

(2) 局部内部类实现实例；

abstract class Animal{
	public abstract void run();
	public abstract void sleep();
}

class Outer{
	public void print(){
		class Dog extends Animal{
			public void run(){
				System.out.println("狗在跑");
			}
			public void sleep(){
				System.out.println("狗在睡觉");
			}
		}
		Dog d = new Dog();//创建对象
		d.run();
		d.sleep();
	}
}
class Demo1{
	public static void main(String[] args){
		Outer outer = new Outer();
		outer.print();
	}
}

运行结果如下图所示:

(3) 匿名内部类实现实例：

abstract class Animal{
	public abstract Animal run();
	public abstract void sleep();
}

class Outer{
	public void print(){
		Animal a = new Animal(){//多态
			//实现Animal类的抽象方法，new Animal整个大括号是个对象，对象需要对象.run();调用方法
			//匿名内部类的成员
			public Animal run(){
				System.out.println("狗在跑……");
				return this;	//this代表当前对象
			}
			public void sleep(){
				System.out.println("狗在睡觉……");
			}
			//特有的方法
			public void bite(){
				System.out.println("狗在咬人……");
			}
		};
		a.run();
		a.sleep();
	}
}

class Demo1{
	public static void main(String[] args){
		Outer outer = new Outer();
		outer.print();
	}
}

运行结果如下图所示：

(4) 匿名内部类注意事项：

①匿名内部类只是没有类名，其他的一概成员都是具备的；

②匿名内部类与Animal是继承 的关系。  Animal a = new Animal( ){}； 是创建Animal子类的对象。目前并不是要创建Animal类的对象，而是借用它父类的名字。创建的是Animal子类的对象。

③类创建对象要使用new 类名();但是匿名内部类没有类名，这时候我们可以想象成不要考虑你没有钱，但是你爹有，这就是匿名内部类使用的前提是继承或者实现关系，因为它本身没有类名，它需要借助它父类或者接口的名字。

④如果出现了子类特有的方法，就不能再使用匿名内部类，因为根本看不到类名，无法做强制类型转换，只能乖乖的用局部内部类。

6. 实现关系下的匿名内部类：

(1) 实例：

interface Dao{
	public void add();
}
class Outer{
	public void print(){
		//创建一个匿名内部类的对象
		new Dao(){ 
		/*
		不是接口不能创建对象吗？怎么现在又可以了？
		现在并不是在创建接口对象，现在创建的是接口的实现类的对象，
		这个实现类是匿名的对象，只不过是借用了接口的名字而已。
		*/  
			 public void add(){
				System.out.println("添加成功");
			 }
		}.add();
	}
}

class Demo1 {
	public static void main(String[] args) {
		test(new Dao(){
			public void add(){
				System.out.println("添加员工成功");
			}
		});
	}
	//调用这个方法...
	public static void  test(Dao d){  
		//形参类型是一个接口引用..接收的是接口类型的对象，传数据只能穿接口的实现类
		//这时候可以自定义一个类去实现一下接口，
		d.add();
	}
}

(2) 运行结果如下图所示：