内部类：在别的类中定义的类
内部类的学习大纲：
1.内部类分类及说明
2.内部类的覆盖
3.内部类的重写
4.使用内部类的优势
Java内部类分类：
静态内部类（static inner class）
成员内部类（member inner class)
局部内部类（local inner class)
匿名内部类（anonymous inner class)
各个类的属性：
静态内部类（访问方式相当于静态方法）：
a.创建静态内部类对象，不需要外部类对象。
b.不能从静态内部类对象中访问非静态的外部类对象成员。
c.接口中可以定义静态内部类
创建：
（方法一）StaticInner.Inner inner = new StaticInner.Inner();
（方法二）import note.StaticInner.Inner;
Inner inner = new Inner()
成员内部类（访问方式相当于成员方法）
能访问外部类中的全部成员变量和方法
2.普通内部类（成员内部类）：
会得到外部类的所用成员的访问权限
.this和.new
.this:内部类获取外部类的对象可直接使用：OutClass.this;
.new: 创建内部类，需要使用外部类的对象 outObj.new InnerClass();
因为成员内部类对象需要使用外部类对象创建，所以持有该外部类对象，所以拥有外部类的所有成员访问权限。
访问权限：
private protected public 默认修饰内部类
private:只可在该外部类中声明和初始化该内部类
默认：只可在同包或者该外部类中声明和初始化内部类
protected：只可在同包，或者外部类的子类，或者该外部类中声明和初始化内部类
public：可在任何类中声明和初始化
对于访问权限不够的内部类，如何在别的类中声明和访问？
声明：可让内部类继承一个外部接口，通过外部接口对象接收内部类
访问：在外部类中定义方法返回该内部类对象
注意：
a.外部类可以访问内部类的任何访问权限的成员（可以访问内部类私有成员）。
b.普通内部类对象隐式的保存了一个引用，指向创建它的外围对象。
c.普通内部类对象不能有static方法和static字段
创建：要创建成员内部类就要先创建外部类（例如要想调用成员方法，必须先初始化一个对象是一样的道理）
MemberInner.Inner memberInner = new MemberInner().new Inner(); 正确、
//MemberInner.Inner memberInner = new MemberInner.Inner(); 错误：创建成员内部类要先创建外部类
局部内部类
局部内部类定义在方法中，比方法的范围还小。是内部类中最少用到的一种类型。
像局部变量一样，不能被public, protected, private和static修饰。
只能访问方法中定义的final类型的局部变量，也可以访问外部类中的成员变量和成员方法
局部内部类在方法中定义，所以只能在方法中使用，即只能在方法当中生成局部内部类的实例并且调用其方法。
使用局部内部类的理由：
a.实现某个接口，于是可以返回对其的引用
b.创建一个辅助的类来帮你解决问题，并且不希望这个类是公用的。
c.局部内部类不能有访问控制权限，与局部变量相通。
注意：
作用域之外不能声明局部内部类。
局部内部类其实与普通类编译都是一样的，只是在作用之外不可用而已。
匿名内部类
匿名内部类就是没有名字的局部内部类，不使用关键字class, extends, implements, 没有构造方法。
匿名内部类隐式地继承了一个父类或者实现了一个接口。
匿名内部类使用得比较多，通常是作为一个方法参数。
public ParaUsb getParaUsb(String name){
return new ParaUsb(name){
String TAG = "OutClass -> ParaUsb:";
String para = getName();
@Override
String convert() {
return TAG + "VGA"; // + name 匿名内部类使用外部类的成员变量，该变量必须是final，否则不可用
}
};
}
注意：
a.匿名内部类使用外部类的成员变量，该变量必须是final，否则不可用
b.可以将外部类的成员通过构造器传给匿名内部类的基类，在该基类中通过方法返回该外部类的成员，即可访问外部类的非final成员
c.匿名内部类与正常的继承相比，限制更大(通过构造器继承，只有一个构造器)，因为匿名内部类即可以继承父类也可以实现接口，但是不能两者兼备，实现接口也只能实现一个接口。
6.多层内部类：
多层内部类 ：一个类无论嵌套多少层内部类，该内部类能透明的访问所有它嵌入的外部类的所有成员。
class OutClass{
void printfOutClass();
class InnerA{
private String name = "A class";
void a(){}
class InnerB{
private String name = "B class";
void b(){
a();
printfOutClass();
}
}
}
}
7.内部类的继承
如果想用一个普通类去继承另一个类的内部类，必须在该普通类的构造方法里加上另一个类的引用
因为：内部类必须要持有外部类的引用。
class ExtendInnerClass{
public ExtendInnerClass(OutClass outClass){
outClass.super(); //构造函数需要连接外部类，不调用，不能通过编译器
}
}
8.内部类的重写：
class A{
InnerA innerA;
public A(){
System.out.println("A");
innerA = new InnerA();
}
public void printf(){
innerA.printf();
}
public void insertInnerA(InnerA a){
innerA = a;
}
class InnerA{
public InnerA(){
System.out.println("InnerA");
}
void printf(){
System.out.println("InnerA");
}
}
}
/**
* 重写内部类不起作用
*/
class ExtendA extends A{
public class InnerA {
public InnerA(){
System.out.println("ExtendA InnerA");
}
void printf(){
System.out.println("ExtendA InnerA");
}
}
public void printf(){
innerA.printf();
}
}
/**
* 重写内部类并且可以使用的方式
*/
class ExtendA2 extends A{
public ExtendA2(){
insertInnerA(new InnerA()); //使用继承的当前内部类替换父类中的内部类
}
public class InnerA extends A.InnerA{
public InnerA(){
System.out.println("ExtendA2 InnerA");
}
void printf(){
System.out.println("ExtendA2 InnerA");
}
}
public void printf(){
innerA.printf();
}
}
public class OverrideInnerClass {
public static void main(String[] args){
ExtendA a = new ExtendA();
a.printf();
ExtendA2 a2 = new ExtendA2();
a2.printf();
}
}
代码：
package note;
import note.StaticInner.Inner;
/**
* 静态内部类{@docRoot 静态内部类只能访问外部类的静态成员变量和静态方法(无论private/public)}
* @author zhaobing
*
*/
class StaticInner{
/**
* 定义一个静态变量，让静态内部类访问
*/
private static String name="StaticInner";
public static void printfExternal(){
System.out.println("external class static method");
}
static class Inner{
void printf(){
System.out.println("this is external class static member (name):" + name);
printfExternal();
}
}
}
/**
* 成员内部类{@docRoot 静态内部类只能访问外部类的成员变量和方法(无论private/public)}
* @author zhaobing
*
*/
class MemberInner{
private String name = "MemberInner";
public void printfExternal(){
System.out.println("External class method");
}
class Inner{
public void printf(){
System.out.println("this is external class member (name):" + name);
printfExternal();
}
}
}
/**
* 在外部类的某一方法中定义类
* 局部内部类 {@docRoot 静外部类的成员变量和方法(无论private/public) 但访问外部类该方法中的非final变量}
* @author zhaobing
*
*/
class LocalInner{
private String name = "LocalInner";
private int age = 10;
private void p(){
System.out.println("test");
}
public void printfExternal(){
int b=3;
final int c=1;
class Inner{
public void printf(String name){
System.out.println(name+c+age);
// System.out.println(name+a+age); 报错 不能访问方法中非final变量
p();
}
}
Inner inner = new Inner();
inner.printf(name);
System.out.println("External class method");
}
}
public class InnerClassDemo {
public static void main(String args[]){
/**
* 静态内部类测试
*/
Inner staticInner=new Inner();
staticInner.printf();
// StaticInner.Inner inner = new StaticInner.Inner(); 也可以使用这种方式创建，这种方式创建的时候不需要import导入
/**
* 成员内部类测试
*/
// MemberInner.Inner memberInner = new MemberInner.Inner(); 错误：创建成员内部类要先创建外部类
MemberInner.Inner memberInner = new MemberInner().new Inner();
memberInner.printf();
/**
* 成员内部类测试
*/
LocalInner localInner = new LocalInner();
localInner.printfExternal();
/**
* 匿名内部类
*/
AnonymousInner anonymousInner = new AnonymousInner();
anonymousInner.printf(new Integer(3));
}
}
class AnonymousInner{
private String name = "AnonymousInner";
public void printf(Integer i){
System.out.println("i:"+i);
}
}