Java内部类
1、内部类访问规则
可以讲内部类看成是外部类中的一个成员，以前怎么看待类中的成员的，现在可以类似的去看待。既然是外部类的一个成员，那么就可以别成员修饰符，private、static等修饰。被private修饰和被static修饰后，所具备的特点（如：被private修饰，则只在本类中有效，不对外暴露，外部其他类不能直接使用）和以前讲过的没有本质的区别，可以类似去套。
外部类中可以建立多个内部类。
内部类的描述和外部类没有区别，该怎么描述还怎么描述。
内部类的访问规则：
1、内部类可以直接访问外部类中的成员，包括私有。
2、外部类要访问内部类，必须建立内部类对象。
访问格式：
1、当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中建立内部类对象。格式：
外部类名.内部类名 变量=外部类对象.内部类对象。
Outer.Inner in=new Outer().new Inner();
这种格式在main（）比较常见，注意由于main是静态的，因此一定不能出现任意形式的非静态。
Ps:Outer.Inner是必须的，不让怎么知道in到底是那个外部类中的内部类的对象。一个程序中可能不只一个外部类。
2、当外部类在成员位置上，就可以被成员修饰符所修饰。
比如：private：将内部类在外部类中进行封装。
Static：内部类就具备了静态特性。
示例：
class Outer
{
private int x=3;
class Inner
{
Int x=4;
void function()
{
int x=6;
System.out.println(“innner:”+x);
}
}
void method()
{
Inner in=new Inner();
in.function();
}
}
class InnerClassDemo
{
public static void main(String[] args)
{
Outer out=new Outer();
outer.method();
}
}
编译运行结果：6（直接找了function（）内部的x，内部有就用内部的）
想打印4：x应改成this.x;
想打印3：x应改成Outer.this.x。
在没有定义int x=4；和int x=3；。输出语句中的x前面省略了Outer.this。这也是为什么内部类可以直接访问外部类中的成员，原来内部类中持有一个外部类的引用。格式：外部类名.this。
2、静态内部类
（1）在外部其他类中，如何直接访问static内部类的非静态成员：
new Outer.Inner().function();
（2）在外部其他类中，如何直接访问static内部类中的静态成员：
Outer.Inner.function();
硬性规定：当内部类中定义了静态成员，该内部类必须是
Static的。此时，外部类访问内部类静态成员，可以建立内部类对象，也可以直接内部类名.形式访问。
3、内部类定义原则
当我们描述事物是，事物的内部还有事物，该事物用内部类来描述。就比如：
class Body
{
}
class XinZang
{
}
那么我们可以：
class Body
{
private class XinZang
{
}
}
心脏直接访问人体里其他器官，且这种组合关系也与实际吻合，人体内有心脏。且在其他外部类（一般指不包含它的类，主要指主类）中可以建立XingZang对象去访问XingZang里边儿的东西。但是你这个心脏被别人直接这么访问，你是不是很受伤，因此，将它私有。不给它提供出去。这些一般用于程序设计中。
4、处在局部位置上的内部类
之前写的内部类都处在成员位置上，只有定义在成员位置上的内部类才能被static、private所修饰，一般内部类是不会被public所修饰，但是这个情况比较特殊。其实内部类的位置是任意的，因此还有局部内部类，局部内部类中常见的是将内部类放在外部类函数中。
如：
class Outer
{
int x=3;
void method()
{
class Inner
{
void function()
{
System.out.println((Outer.this.)x);
}
}
}
}
但是此时在外部其他类中建立Outer对象，调用method（），程序不能运行。Method（）不会一步一步往下走，因为Inner没对象，它是不会运行的。
因此：
class Outer
{
int x=3;
void method()
{
class Inner
{
void function()
{
System.out.println((Outer.this.)x);
}
}
new Inner().function();
}
}
注意：划线的两个地方不能互换。如果函数内部定义了一个x变量，那么这个Outer.this不能省略。省略了x就是指函数内部的变量，如果这个函数内部的变量没有别final修饰的话，编译将会失败。
内部类定义在局部时，
1、不可以被成员修饰符修饰。
2、还可以直接访问外部类中的成员，因为还持有外部类的引用。但是不可以访问它所在的局部中的变量。只能访问被final修饰的局部变量。
5、匿名内类(处在成员位置上)
匿名内部类其实就是内部类的简写形式。
再讲对象的时候说过：
class Outer
{
int x=3;
class Inner
{
void method()
{
System.out.println(”method：“+x);
}
}
public void function()
{
new Inner().method();
}
}
class InnerClassDemo
{
public static void main(String[] args)
{
new Outer().function();
}
}
因为这对象我可能只使用一次，所以直接使用匿名创建。
现在的话：
定义内部类的前提：内部类必须是继承某一个类或者是实现了某一接口。
（1）abstract class AbsDemo
{
abstract void show();
}
class Outer
{
int x=3;
class Inner extends AbsDemo
{
void show()
{
System.out.println(“show:”+x);
}
}
public void function()
{
new Inner().show();
}
}
class InnerClassDemo
{
public static void main(String[] args)
{
new Outer().function();
}
}
（2）abstract class AbsDemo
{
abstract void show();
}
class Outer
{
int x=3;
/*
class Inner extends AbsDemo
{
void show()
{
System.out.println(“show:”+x);
}
}
*/
public void function()
{
//new AbsDemo();父类是个抽象类不能实例化
New AbsDemo()
{
Void show()
{
System.out.println(“x=”+x);
}
}
}.show();
}
class InnerClassDemo
{
public static void main(String[] args)
{
new Outer().function();
}
}
开发中写Awt时经常出现。它是一个很胖的对象，把show（）复写了，是子类的对象。我们还可以在这个子类对象中定义子类特有的内容，不管是成员变量还是成员方法。
（3）abstract class AbsDemo
{
abstract void show();
}
class Outer
{
int x=3;
/*
class Inner extends AbsDemo
{
void show()
{
System.out.println(“show:”+x);
}
}
*/
public void function()
{
//new AbsDemo();父类是个抽象类不能实例化
New AbsDemo()
{
int x=8;
Void show()
{
System.out.println(“x=”+x);
}
void abc()//子类特有
{
System.out.println(“haha”);
}
}
}.show();
}
class InnerClassDemo
{
public static void main(String[] args)
{
new Outer().function();
}
}
子类对象没有名字，因此后面只能调用一个成员，可以是show（），也可以是abc（）。如果想调用多个，需要给它起个名字，但是，由于是匿名类，所以只能是利用多态:
（4）abstract class AbsDemo
{
abstract void show();
}
class Outer
{
int x=3;
public void function()
{
AbsDemo d=new AbsDemo()
{
int x=8;
Void show()
{
System.out.println(“x=”+x);
}
void abc()//子类特有
{
System.out.println(“haha”);
}
}
};
d.show();
d.abc();
}
class InnerClassDemo
{
public static void main(String[] args)
{
new Outer().function();
}
}
但是编译时失败，因为多态中成员函数的特点。这是匿名内部类的第一大缺点。
匿名内部类中定义的方法最好不要超过3个。否则那个对象会很“胖”。这样代码看起来其实很烂。这是匿名内部类的第二大缺点。
说到底：匿名内部类主要就是创建匿名内部类的对象。
练习：
interface Inter
{
Abstract void method();
}
class Test
{
//补足代码。通过匿名内部类。
}
class InnerClassTest
{
Public static vioid main(String[] args)
{
Test.function().method();
}
}
从Test.function().method();这句话可以知道：Test类中有一个静态方法function（）。function（）这个方法运算后的结果是一个对象。而且是一个Inter类型的对象，因为只有是Inter类型的对象才可以调用method方法。因此：
有名字的内部类：
interface Inter
{
Abstract void method();
}
class Test
{
//由于function是静态的，所以Inner也定义为静态的。
//否则function中不能有Inner。
static class Inner implements Inter
{
public void method()
{
System.out.println(“method run”);
}
}
static Inner functhion()
{
return new Inner();
}
}
class InnerClassTest
{
Public static vioid main(String[] args)
{
Test.function().method();
}
}
匿名内部类：
interface Inter
{
Abstract void method();
}
class Test
{
static Inner functhion()
{
return new Inter()
{
public void method()
{
System.out.println(“method run”);
}
};
}
}
class InnerClassTest
{
Public static vioid main(String[] args)
{
Test.function().method();
}
}
说到这，我们可以拓展：匿名类对象作为一个参数传给函数：
interface Inter
{
Abstract void method();
}
class InnerClassTest
{
public static vioid main(String[] args)
{
show(new Inter()
{
public void method()
{
System.out.println(“method show run”);
}
});
}
public static void show(Inter in)
{
in.method();
}
}
那如果没有直接的父类或者接口，且要求匿名怎么办呢？别忘了Object类是所有类的父类。看下面的例子：
class InnerTest
{
public static void main(String[] args)
{
//new Object（）；这是可以的，Object类不是抽象类， //可以实例化
new Object()
{
public void function()
{
.....
}
}.function();
}
}
但是下面的情况编译是不通过的。
class InnerTest
{
public static void main(String[] args)
{
//new Object（）；这是可以的，Object类不是抽象类， //可以实例化
Object o=new Object()
{
public void function()
{
.....
}
};
O.function()；
}
}
原因：父类中并没有function，这种方式只能调用父类中有的方法。
2015-11-21至2015-11-22著
313
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
