JAVA基础——内部类、匿名内部类

什么是内部类？

顾名思义，在类内部定义的类。

内部类的访问：

1、内部类可以直接访问外部类中的成员，包括私有。

之所以可以直接访问外部类中的成员，是因为内部类中持有了一个外部类的引用，格式 外部类名.this

2、外部类要访问内部类，必须建立内部类对象。

3、其他类直接访问内部类成员(内部类不能是私有的)，可用new 外部类.new 内部类.成员

class Outer
{
private int x=3;
class Inner
{
void function()
{
System.out.println("Inner:"+x); //1,内部类访问外部类成员<==>Outer.this.x
}
}
void show()		//2,外部类访问内部类：通过内部类对象访问
{
Inner in=new Inner();
in.function();
}
}
class InnerClassDemo
{
public static void main(String[] args)
{
Outer o =new Outer();
o.show();
//3,直接访问内部类成员
new Outer().new Inner().function();
//或者
Outer.Inner in=new Outer().new Inner();
in.function();
}
}

带有修饰的内部类：

内部类同成员一样可以被修饰符修饰。

private修饰：对内部类进行封装。

static修饰：外部类一被加载就加载了内部类。

关于static在这里有一些注意事项：

1、内部类被static修饰时，只能直接访问外部类中的static成员。

2、其他类访问static内部类的static成员时：outer.inner.function();-----外部类名.内部类名.static成员

3、其他类访问static内部类的非static成员时：new outer.inner().function();--------new 外部类名.内部类名().非static成员

4、当内部类中定义了静态成员，则该内部类必须是静态的

5、当外部类的静态方法访问了内部类时，则内部类必须是静态的

内部类定义在局部时：

1、不能被成员修饰符修饰，因为它已经不是成员了。-------因此定义在局部的类中的成员不能是静态的，否则这个类必须是静态的，而这个类不能被静态修饰！

2、可以直接访问外部类中的成员，因为还持有外部类中的引用。但是不可以访问它所在的局部中的变量。只能访问被final修饰的局部变量。

class A{
public void method(){
int  x=3;
class B{
public void method(){
System.out.println(x); //错不能访问 X必须final修饰
}
}
}
}

匿名内部类：

1，匿名内部类其实就是内部类的简写格式。

2，定义匿名内部类的前提：
内部类必须是继承一个类或者实现接口。

3，匿名内部类的格式：  new 父类或者接口(){定义子类的内容}

4，其实匿名内部类就是一个匿名子类对象。可以理解为带内容的对象。

5，匿名内部类中定义的方法最好不要超过3个。

不用匿名内部类时：

abstract class AbsClass
{
abstract void show();
}
class Outer
{
class Inner extends AbsClass
{
void show()
{
System.out.println("haha");
}
}

void function()
{
Inner in=new Inner();
in.show();
}
}
class NiMingInnerClass
{
public static void main(String[] args)
{
Outer o=new Outer();
o.function();
}
}

使用匿名内部类时：

abstract class AbsClass
{
abstract void show();
}
class Outer
{
void function()
{
new AbsClass()
{
void show()
{
System.out.println("haha");
}
}.show();
}
}
class NiMingInnerClass
{
public static void main(String[] args)
{
Outer o=new Outer();
o.function();
}
}

给匿名内部类对象起名：

当匿名内部类中有多个方法时，每次都用new 类名(){}.方法，太麻烦。可以利用多态给匿名内部类对象起名；

如上例可用下面代码给匿名内部类起名：

function中的部分可以换成：

AbsClass abs=new AbsClass()
{
void show()
{
System.out.println("haha");
}
};
abs.show();

给匿名内部类对象起名的弊端：

假如匿名内部类想要有自己特有的方法，比如匿名内部类中还有个void abc()方法，但父类Absclass中没有这个方法，则匿名内部类无法调用自己特有的方法。

如下：

void function()
{
AbsClass abs=new AbsClass()
{
void show()
{
System.out.println("haha");
}
void abc()
{
System.out.println("abc");
}
};
abs.show();
abs.abc(): //编译失败。父类没有此方法，多态性导致。
}

但是如果给匿名内部类对象起名，直接用new AbsClass(){…………}.abc()就可以，但是显然匿名内部类体中函数太多会使代码异常臃肿，而且占用堆类内存。