内部类仍然是一个独立的类，在编译之后内部类会被编译成独立的.class文件，但是前面冠以外部类的类名和$符号。
成员内部类（作为外部类的成员）
1.内部类可以直接访问外部类的成员，包括私有的。
之所以可以直接访问外部类中的成员，是因为内部类中持有了一个外部类的引用，格式：外部类名.this.成员名（外部类名.this.可以省略不写）
2.外部类要访问内部类得通过new内部类对象。格式：内部类名 对象名=new 内部类名（）；对象名.成员名。
3.内部类声明成静态的，就不能随便的访问外部类的成员了，此时内部类只能访问外部类的静态成员。
4.当内部类定义在外部类的成员位置上，而且非私有。在外部其他类中，可以建立内部类对象访问该内部类。格式 ： 外部类名.内部类名 对象名=new 外部类名().new 内部类名();如：Outer.Inner k=new Outer().new Inner();
5.在外部其他类中，如何访问static内部类的非静态成员呢？创建对象。如new 外部类名.内部类名.方法名（）。
6.在外部其他类中，如何访问static内部类的静态成员呢？不需创建对象。外部类名.内部类名.方法名（）。
7.当内部类定义了静态成员，该内部类必须是静态的！
访问权限：顶层类(就是最外层的类) 只有2个作用域(包→任意位置)，所以其只能有package、public两种访问权限。
内部类 可以是静态static的，也可用public，default，protected和private修饰。
局部变量 它的作用域是所在方法，不能被外部访问，所以局部成员没有访问权限。
class Outer{
private int x=3;
void method(){
Inner in=new Inner();
in.function();//外部类要访问内部类得通过new内部类对象。
}
class Inner{//内部类
void function(){
System.out.println("inner:"+x); //内部类可以直接访问外部类的成员
}
}
}
public class Test{
public static void main(String[]args){
Outer out=new Outer();
out.method();
//创建内部类对象访问内部类中的成员，如下：（注意：如果内部类被private修饰了就不能这样访问了。）
Outer.Inner k=new Outer().new Inner();
k.function();
}
}
*****************************************
内部类可以定义跟外部类成员名相同的成员。
class Outer{
private int x=3;
class Inner{//内部类
int x=4;
void function(){
int x=6;
System.out.println("inner:"+x); //打印的是6.(首先在方法内部找，方法内部有x就会输出内部的。)
System.out.println("inner:"+this.x); //打印的是4.(this.x,找内部类的x。)
System.out.println("inner:"+Outer.this.x); //打印的是4.(Outer.this.x，去找外部类的x),内部类持有外部类的引用。
}
}
void method(){
Inner in=new Inner();
in.function();
}
}
public class nn{
public static void main(String[]args){
Outer k=new Outer();
k.method();
}
}
什么时候使用内部类：
当描述事物时，事物的内部还有事物，该事物用内部类来描述。
因为内部事物在使用外部事物的内容。
class Body{
private class xinzang{//内部类一般会封装起来，不对外暴露，而是提供方法给外部访问。
}
public void show(){//提供方法给外部访问。
new xinzang（）.成员名;
}
}
方法内部类（定义在外部类的方法里，是局部的）
class Outer{
int x=3;
void method(){
new Inner().function;//不能在这里new内部类对象。
class Inner{//方法内部类
void function(){
System.out.println("inner:"+x);
}
}
new Inner().function();//new方法内部类的对象，必须在内部类下面该方法里面，因为如果在上面new的后，java虚拟机还没有把内部类加载进来。而在方法外面new的话，该方法加载完就在内存中消失了。
}
}
public class nn{
public static void main(String[]args){
new Outer().method();
}
}
1.不可以被成员修饰符修饰,因为它是定义在方法内部的，是局部的。
2.可以直接访问外部类中的成员，因为还持有外部类中的引用。
但是不可以访问它所在局部中的变量，只能访问被final修饰的局部变量。
3.方法内部类只能在定义该内部类的方法内实例化，不可以在此方法外对其实例化。
4.方法内部类中不能定义静态成员，因为如果内部类中有静态成员，那么内部类也必须是静态的。
而方法内部类是是在方法里面的，是局部的，不能定义为static。
因为方法的
局部变量位于栈上，只存在于该方法的
生命期内。当一个方法结束，其栈结构被删除，
局部变量成为历史。但是该方法结束之后，在方法内创建的内部类对象可能仍然存在于堆中！例如，如果对它的引用被传递到其他某些代码，并存储在一个
成员变量内。正因为不能保证
局部变量的存活期和方法内部类对象的一样长，所以内部类对象不能使用它们。
4匿名内部类
1.匿名内部类就是内部类的简写格式
2.定义内部类的前提：内部类必须是继承一个类或实现一个接口。
3.匿名内部类的格式：new父类或者接口（){实现父类或者接口的方法，定义子类内容}
4.其实匿名内部类就是一个匿名子类对象。而且这个对象有点胖。
5.匿名内部类中定义的方法最好不要超过三个。
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(){
/*AbsDemo k =new Inner();
k.show();
*/
AbsDemo k =new AbsDemo(){//匿名内部类其实就是上面注悉的代码的简写。父类引用指向子类对象，是多态形式。
void show(){
System.out.println("show:"+x);
}
void abc(){
System.out.println("show:"+x);
}
} k.show();//可以
k.abc();//不可以，因为K是父类对象的引用，只能访问父类的方法。父类中没有定义过这个方法。
}
什么情况下需要使用匿名内部类？如果满足下面的一些条件，使用匿名内部类是比较合适的：
·只用到类的一个实例。
·类在定义后马上用到。
·类非常小（SUN推荐是在4行代码以下）
·给类命名并不会导致你的代码更容易被理解。
在使用匿名内部类时，要记住以下几个原则：
·匿名内部类不能是public,protected,private,static。
·只能创建匿名内部类的一个实例。
·因匿名内部类为局部内部类，所以局部内部类的所有限制都对其生效。
A、继承式的匿名内部类
public class Car {
public void drive(){
System.out.println("Driving a car!");
}
public static void main(String[] args) {
Car car = new Car(){
public void drive() {
System.out.println("Driving another car!");
}
};
car.drive();
}
}
结果输出了：Driving another car! Car
引用变量不是引用Car对象，而是Car匿名子类的对象。
B、接口式的匿名内部类。
interface Vehicle {
public void drive();
}
class Test{
public static void main(String[] args) {
Vehicle v = new Vehicle(){
public void drive(){
System.out.println("Driving a car!");
}
};
v.drive();
}
}
上面的代码很怪，好像是在实例化一个接口。事实并非如此，接口式的匿名内部类是实现了一个接口的匿名类。而且只能实现一个接口。
C、参数式的匿名内部类。
class Bar{
void doStuff(Foo f){
f.foo();
}
}
interface Foo{
void foo();
}
class Test{
static void go(){
Bar b = new Bar();
b.doStuff(new Foo(){
public void foo(){
System.out.println("foofy");
}
});
}
}
5静态嵌套类
从技术上讲，静态嵌套类不属于内部类。因为内部类与外部类共享一种特殊关系，更确切地说是对实例的共享关系。而静态嵌套类则没有上述关系。它只是位置在另一个类的内部，因此也被称为顶级嵌套类。
静态的含义是该内部类可以像其他
静态成员一样，没有外部类对象时，也能够访问它。静态嵌套类仅能访问外部类的静态成员和方法。
class Outer{
static class Inner{}
}
class Test {
public static void main(String[] args){
Outer.Inner n = new Outer.Inner();
}
}
在静态方法中定义的内部类也是StaticNested Class，这时候不能在类前面加static关键字，静态方法中的StaticNested Class与普通方法中的内部类的应用方式很相似，它除了可以直接访问外部类中的static的成员变量，还可以访问静态方法中的局部变量，但是，该局部变量前必须加final修饰符。
为什么需要内部类
典型的情况是，内部类继承自某个类或实现某个接口，内部类的代码操作创建其的外围类的对象。所以你可以认为内部类提供了某种进入其外围类的窗口。使用内部类最吸引人的原因是：
每个内部类都能独立地继承自一个（接口的）实现，所以无论外围类是否已经继承了某个（接口的）实现，对于内部类都没有影响。如果没有内部类提供的可以继承多个具体的或抽象的类的能力，一些设计与编程问题就很难解决。从这个角度看，内部类使得
多重继承的解决方案变得完整。接口解决了部分问题，而内部类有效地实现了“
多重继承”。
浙公网安备 33010602011771号