面向对象：13、内部类

很多时候我们创建类的对象的时候并不需要使用很多次，每次只使用一次，这个时候我们就可以使用内部类了。

1、内部类概述

内部类就是在一个类的内部在定义一个类，比如，A类中定义一个B类，那么B类相对A类来说就称为内部类，而A类相对B类来说就是外部类了。

内部类不是在一个java源文件中编写俩个平行的俩个类,而是在一个类的内部再定义另外一个类。我们可以把外边的类称为外部类,在其内部编写的类称为内部类。

内部类分为四种：

成员内部类
静态内部类
局部内部类
匿名内部类

2、成员内部类（实例内部类、非静态内部类）

定义一个内部类（成员内部类中不能写静态属性和方法）

//在A类中申明了一个B类，此B类就在A的内部，并且在成员变量的位置上，所以就称为成员内部类
public class Outer {private int id;public void out(){System.out.println("这是外部类方法");}class Inner{public void in(){System.out.println("这是内部类方法");}}
}

实例化内部类（实例化内部类，首先需要实例化外部类，通过外部类去调用内部类）

public class Outer {private int id;public void out(){System.out.println("这是外部类方法");}class Inner{public void in(){System.out.println("这是内部类方法");}}
}
public class Test{public static void main(String[] args) {//实例化成员内部类分两步//1、实例化外部类Outer outObject = new Outer();//2、通过外部类调用内部类Outer.Inner inObject = outObject.new Inner();//测试，调用内部类中的方法inObject.in();//打印：这是内部类方法}
}

成员内部类的作用

访问外部类的所有属性(这里的属性包括私有的成员变量，方法)

public class Outer {private int id;public void out(){System.out.println("这是外部类方法");}class Inner{public void in(){System.out.println("这是内部类方法");}//内部类访问外部类私有的成员变量public void useId(){System.out.println(id+3);。}//内部类访问外部类的方法public void useOut(){out();}}
}
public class Test{public static void main(String[] args) {//实例化成员内部类分两步//1、实例化外部类Outer outObject = new Outer();//2、通过外部类调用内部类Outer.Inner inObject = outObject.new Inner();//测试inObject.useId();//打印3，因为id初始化值为0，0+3就为3，其中在内部类就使用了外部类的私有成员变量id。inObject.useOut();//打印：这是外部类方法}
}

如果内部类中的变量名和外部类的成员变量名一样，要通过创建外部类对象 "."属性来访问外部类属性，通过this.属性访问内部类成员属性

public class Outer {private int id;//默认初始化0public void out(){System.out.println("这是外部类方法");}class Inner{private int id=8; //这个id跟外部类的属性id名称一样。public void in(){System.out.println("这是内部类方法");}public void test(){System.out.println(id);//输出8，内部类中的变量会暂时将外部类的成员变量给隐藏//如何调用外部类的成员变量呢？通过Outer.this，想要知道为什么能通过这个来调用，就得明白下面这个原理//想实例化内部类对象，就必须通过外部类对象，当外部类对象来new出内部类对象时，会//把自己(外部类对象)的引用传到了内部类中，所以内部类就可以通过//Outer.this来访问外部类的属性和方法，到这里，你也就可以知道为什么内部类可以访问外部类//的属性和方法，这里由于有两个相同的//属性名称，所以需要显示的用Outer.this来调用外部类的属性，平常如果属性名//不重复，那么我们在内部类中调用外部类的属性和方法时，前面就隐式的调用了Outer.this。System.out.println(Outer.this.id);//输出外部类的属性id。也就是输出0}}
}

3、静态内部类

static修饰的内部类就叫静态内部类

static一般只修饰变量和方法，平常不可以修饰类，但是内部类却可以被static修饰

1）static修饰成员变量：整个类的实例共享静态变量

2）static修饰方法：静态方法，只能够访问用static修饰的属性或方法，而非静态方法可以访问static修饰的方法或属性

3）被static修饰了的成员变量和方法能直接被类名调用

4）static不能修饰局部变量

public class StaticInnerClassTest {private String name;private static int age;public void run(){}public static void go(){}//外部类访问静态内部类public void test(){StaticInnerClass sic = new StaticInnerClass(); //静态的内部类不需要依赖外部类，所以不用thissic.name = "tom";sic.test1("jack");StaticInnerClass.age=10;StaticInnerClass.test2("xixi");}private static class StaticInnerClass{private String name;private static int age;public void test1(String name){System.out.println(name);System.out.println(this.name);System.out.println(StaticInnerClass.age);System.out.println(StaticInnerClassTest.age);//System.out.println(StaticInnerClassTest.this.name);静态类不能访问非静态属性StaticInnerClassTest.go();//StaticInnerClassTest.this.run();静态类不能访问非静态方法}public static void test2(String name){//只能访问自己和外部类的静态属性和方法System.out.println(name);//System.out.println(this.name);静态方法里面连自己类的非静态属性都不能访问System.out.println(StaticInnerClass.age);System.out.println(StaticInnerClassTest.age);//System.out.println(StaticInnerClassTest.this.name);静态方法不能访问非静态属性StaticInnerClassTest.go();//StaticInnerClassTest.this.run();静态方法不能访问非静态方法}}
}

内部类能够调用外部类的方法和属性，在静态内部类中就行了，因为静态内部类没有了指向外部类对象的引用。除非外部类中的方法或者属性也是静态的。这就回归到了static关键字的用法。
静态内部类能够直接被外部类给实例化，不需要使用外部类对象

Outer.Inner inner = new Outer.Inner();

静态内部类中可以声明静态方法和静态变量，但是非静态内部类中就不可以声明静态方法和静态变量

4、局部内部类

局部内部类是在一个方法内部声明的一个类
局部内部类中可以访问外部类的成员变量及方法
局部内部类中如果要访问该内部类所在方法中的局部变量,那么这个局部变量就必须是final修饰的

public class Outer {private int id;//在method01方法中有一个Inner内部类，这个内部类就称为局部内部类public void method01(){class Inner{public void in(){System.out.println("这是局部内部类");}}}
}

在局部内部类中，如果要访问局部变量，那么该局部变量要用final修饰

为什么需要使用final？

final修饰变量：变为常量，会在常量池中放着，逆向思维想这个问题，如果不实用final修饰，当局部内部类被实例化后，方法弹栈，局部变量跟着消失，这个时候局部内部类对象再想去调用该局部变量，就会报错，因为该局部变量已经没了，当局部变量用final修饰后，就会将其加入常量池中，即使方法弹栈了，该局部变量还在常量池中呆着，局部内部类才能够调用。

所以局部内部类想要调用局部变量时，需要使用final修饰，不使用，编译无法通过

public class Outer {private int id;public void method01(){final int cid = 3; //这个就是局部变量cid。要让局部内部类使用，就得变为final并且赋值，如果不使用final修饰，就会报错class Inner{//内部类的第一个方法public void in(){System.out.println("这是局部内部类");}//内部类中的使用局部变量cid的方法public void useCid(){System.out.println(cid);}}}
}

局部内部类不能通过外部类对象直接实例化，而是在方法中实例化出自己来，然后通过内部类对象调用自己类中的方法

public class Outer {private int id;public void out(){System.out.println("外部类方法");}public void method01(){class Inner{public void in(){System.out.println("这是局部内部类");}}//关键在这里，如需要在method01方法中自己创建内部类实例，然后调用内部类中的方法，等待外部类调用method01方法，就可以执行到内部类中的方法了。Inner In = new Inner();In.in();}
}

5、匿名内部类

匿名内部类是最常用的一种内部类。

什么是匿名对象？

如果一个对象只要使用一次，那么我们就是需要new Object().method()。就可以了，而不需要给这个实例保存到该类型变量中去。这就是匿名对象。

匿名内部类跟匿名对象是一个道理：

匿名对象：我只需要用一次，那么我就不用声明一个该类型变量来保存对象了

匿名内部类：我也只需要用一次，那我就不需要在类中先定义一个内部类，而是等待需要用的时候，我就在临时实现这个内部类，因为用次数少，可能就这一次，那么这样写内部类，更方便。不然先写出一个内部类的全部实现来，然后就调用它一次，就会导致资源的浪费

匿名内部类需要依托于其他类或者接口来创建
如果依托的是类,那么创建出来的匿名内部类就默认是这个类的子类
如果依托的是接口,那么创建出来的匿名内部类就默认是这个接口的实现类。
匿名内部类的声明必须是在使用new关键字的时候
匿名内部类的声明及创建对象必须一气呵成,并且之后能反复使用,因为没有名字。

main:
A a = new A(){//实现A中的抽象方法//或者重写A中的普通方法
};
注:这个大括号里面其实就是这个内部类的代码,只不过是声明该内部类的同时就是要new创建了其对象,
并且不能反复使用,因为没有名字。例如:
B是一个接口，依托于B接口创建一个匿名内部类对象B b = new B(){//实现B中的抽象方法
};

匿名内部类除了依托的类或接口之外,不能指定继承或者实现其他类或接口,同时也不能被其他类所继承,因为没有名字
匿名内部中,我们不能写出其构造器,因为没有名字
匿名内部中,除了重写上面的方法外,一般不会再写其他独有的方法,因为从外部不能直接调用到。(间接是调用到的)