Java-内部类

一、内部类：（成员内部类、静态内部类、局部内部类、匿名内部类）
1.概念：在一个类的内部，再定义一个完整的类。
class Outer{ class Inner { } }
2.特点：
I.编译之后可生成独立的字节码文件。>>Outer&Inner.class Outer.class
II.内部类可直接访问外部类的私有成员，而不破坏封装。
class Outer{ private int a ; class Inner {public void m2(){System.out.pritln(a);} } }
III.可为外部类提供必要的内部功能组件。
内部类可以仅服务于外部类，完成一些方法
3.分类：
I.成员内部类：
1).在类的内部定义，与实例/成员变量、实例方法同级别的类。（对象被创建的时候）
2).属于外部类的一个实例部分，创建内部类对象，必须依赖外部类对象。
3). Outer out = new Outer(); //创建外部类对象
Outer.Inner in = out.new Inner(); //访问内部类
4).当外部类、内部类存在重名属性时，有限访问内部类属性，通过外部类类名.this.外部类实例属性
class Outer{
private int a = 10;
class Inner {
int a = 20;
public void m2(){
int a = 30;
System.out.pritln(a);//内部类可以访问自身局部变量
System.out.pritln(this.a); //内部类可以访问内部类的实例变量
System.out.pritln(Outer.this.a); //内部类可以访问外部类的实例变量
} } }
5).成员内部类不能定义静态成员。
无法脱离外部类对象进行静态的调用
II.静态内部类：
1).不依赖外部类对象，可直接创建或通过类名访问，也可声明静态成员。
2).只能直接访问外部类的静态成员（实例成员需要实例化外部类对象）
//通过外部类类名.内部类类名.内部类的静态属性
Outer.Inner.静态成员 //额外比成员内部类多了一个定义的内容（静态属性和静态方法）
//创建静态内部类对象时，可以直接通过完整名称进行创建
Outer.Inner in = new Outer.Inner(); //访问静态内部类
//通过外部类类名.内部类类名.内部类的静态方法
Outer.Inner.show(); // 访问内部类的静态方法
III.局部：
1).定义在外部类的方法中，作用范围和创建对象的范围仅限当前方法中。
2).局部内部类访问外部类局部变量时，因无法保障变量的生命周期与自身相同，所以修饰为final。
局部变量的生命周期可能和局部内部类的对象的生命周期不一致，加入了final之后能保证局部变量的生命周期是大于局部内部类对象的生命周期，进而可在任何时候对象进行局部变量访问时都保证变（常）量有值
局部变量在栈中，使用完伴随着方法立刻回收 final常量永远消失在对它作访问的对象之后
对象在堆中伴随着Java垃圾回收GC回收一个周期（程序员不干预的情况下，再快没有内存的情况下最后回收）在方法之后依旧能查询这个对象。且这个时候不能访问局部变量。

main(){  Outer out = new Outer();  out.m1(); }
class Outer{
public void m1(){
final String local = “”Hello;
class Inner{
public void m2(){
System.out.println(“Inner – m2()” + local);
}
}
Inner in = new Inner();
in.m2();
}
}

3).隐藏类的信息、限制类的使用范围。

public class TestSchool{
	public static void main(String[] args){
Teacher t = School.getTeacher(3);
t.teach();
}	}
		class School{
public static Teacher randomChoose(int classNO){
class BeginnerTeacher extends Teacher{
	public void teach(){
	System.out.println(“初级老师在上课”);
}	}
class AdvanceTeacher extends Teacher{
	public void teach(){
	System.out.println(“高级老师在上课”);
}	}
	Teacher t = null;
	if(classNO % 2 != 0){
	t = new AdvencedTeacher();
}else{
t = new BeginnerTeacher();
}
return t ;
}	}
			
			abstract class Teacher{
	public abstract void teach();
}	

局部内部类（一个方法可以访问） < 私有的成员内部类 （本类中的所有方法都可以访问）<私有静态内部类（本类可以访问，静态，非静态）<非私有成员内部类 公开成员内部类 default成员内部类（内部，外部 都可用）<非私有静态内部类<公开静态内部类 普通公开类（区别在调用）

IV.匿名： （1.想用局部内部类-隐藏类的信息 2.继承一个类实现一个接口）
1).没有类名的局部内部类
2).必须继承一个父类或实现一个接口。
3).定义类、实现类、创建对象的语法合并，只能创建一个该类的对象。
4).优：更符合程序员书写规律，减少代码量，书写的思路流畅。
5).劣：可读性较差。

Tescher t = null;//返回值
if(classN0 % 2! = 0){
t = new Teacher(){
	public void teach(){
	System.out.println(“初级老师在上课//”);
}
};
}else{
	t = new Teacher(){
	public void teach(){
System.out.println(“高级老师在上课//”);
}
}
return t;
}

Tescher t = null;//返回值
class BeginnerTeacher extends Teacher{//局部内部类（隐藏内部类）
public void teach(){
System.out.println(“初级老师在上课”);}}
/
if(classN0 % 2! = 0){//匿名内部类
t = new Teacher(){
	public void teach(){
	System.out.println(“高级老师在上课//”);
}
};
}else{
	t = new  BeginnerTeacher()；
}
return t;
}

///2/
1.用一次，2.要用父类的方法做覆盖.
main(){

Aniamla a  new Dog();
Animal a2 = new Animal(){
	public void eat(){System.out.println(“狗在吃骨头。”);}
};//重新做一个实现
Swimmable s = new Swimmable(){
public void swim(){System.out.println(“自由自在的游泳”);}}
}

class Animal{
public void eat(){System.out.prinltn(“动物在吃”);}}

interface Swimmable{
public void swim();}

//*class Dog extends Animal{
public void eat(){System.out.println(“狗在吃”);}}

API：Application Programming Interface
*/