内部类

内部类的共性
(1)、内部类仍然是一个独立的类，在编译之后内部类会被编译成独立的.class文件，但是前面冠以外部类的类名和$符号 。
(2)、内部类不能用普通的方式访问。内部类是外部类的一个成员，因此内部类可以自由地访问外部类的成员变量，无论是否是private的 。
(3)、静态内部类不能随便的访问外部类的成员变量了，只能访问外部类的静态成员 。

程序编译过后会产生两个.class文件，分别是Out.class和Out$In.class

其中$代表了上面程序中Out.In中的那个 .

Out.In in = new Out().new In()可以用来生成内部类的对象

　　1.开头的Out是为了标明需要生成的内部类对象在哪个外部类当中

　　2.必须先有外部类的对象才能生成内部类的对象，因为内部类的作用就是为了访问外部类中的成员变量

//外部类的非静态方法访问成员内部类（  外部类的非静态方法属于外部类的对象，即调用外部类的静态方法已经 创建过外部类的对象，）
public void outer_f3(){
    Inner inner = new Inner();
    inner.inner_f1();
}

外部类的静态方法访问成员内部类，与在外部类外部访问成员内部类一样（成员内部类是外部类的成员，访问非静态成员需要外部类的对象）<-（如下：类名.outer_f4();则并未创建过外部类的对象）

public static void outer_f4(){
    //step1 建立外部类对象
    Outer out = new Outer();
    //***step2 根据外部类对象建立内部类对象***
    Inner inner=out.new Inner();
    //step3 访问内部类的方法
    inner.inner_f1();
}

内部类的基本结构

 成员内部类：即作为外部类的一个成员存在，与外部类的属性、方法并列。

          注意：成员内部类中不能定义静态变量,但可以访问外部类的所有成员。

非静态内部类

运行结果：12

内部类可以随意使用外部类的成员变量（包括私有）而不用生成外部类的对象，这也是内部类的唯一优点

   非静态内部类被private修饰

运行结果：12

如果一个内部类只希望被外部类中的方法操作，那么可以使用private声明内部类

上面的代码中，我们必须在Out类里面生成In类的对象进行操作，而无法再使用Out.In in = new Out().new In() 生成内部类的对象

也就是说，此时的内部类只有外部类可控制

变量访问形式

运行结果：

局部变量：14
内部类变量：13
外部类变量：12

从中可以发现，内部类在没有同名成员变量和局部变量的情况下，内部类会直接访问外部类的成员变量，而无需指定Out.this.属性名

否则，内部类中的局部变量会覆盖外部类的成员变量

而访问内部类本身的成员变量可用this.属性名，访问外部类的成员变量需要使用Out.this.属性名

 

静态内部类  静态内部类定义在类中，任何方法外。静态内部类可以用public,protected,private修饰
注意：静态内部类中可以定义静态或者非静态的成员

运行结果：12

可以看到，如果用static 将内部内静态化，那么内部类就只能访问外部类的静态成员变量，具有局限性

其次，因为内部类被静态化，因此Out.In可以当做一个整体看，可以直接new 出内部类的对象（通过类名访问static，生不生成外部类对象都没关系）

 

方法内部类： 即在方法中定义的内部类，与局部变量类似，在方法内部类前不加修饰符public或private，其范围为定义它的代码块。

注意：方法内部类中不可定义静态变量，可以访问外部类的局部变量(即方法内的变量)，但是变量必须是final的。
在类外不可直接生成局部内部类（保证局部内部类对外是不可见的）。要想使用局部内部类时需要生成对象，对象调用方法，在方法中才能调用其局部内部类。通过内部类和接口达到一个强制的弱耦合，用局部内部类来实现接口，并在方法中返回接口类型，使局部内部类不可见，屏蔽实现类的可见性。
在静态方法中定义的内部类也是静态嵌套类，这时候不能在类前面加static关键字，静态方法中的静态嵌套类与普通方法中的内部类的应用方式很相似，它除了可以直接访问外部类中的static的成员变量，还可以访问静态方法中的局部变量，但是，该局部变量前必须加final修饰符。

运行结果：

3
12

在上面的代码中，我们将内部类移到了外部类的方法中，然后在外部类的方法中再生成一个内部类对象去调用内部类方法

如果此时我们需要往外部类的方法中传入参数，那么外部类的方法形参必须使用final定义

至于final在这里并没有特殊含义，只是一种表示形式而已

(1)、方法内部类只能在定义该内部类的方法内实例化，不可以在此方法外对其实例化。
(2)、方法内部类对象不能使用该内部类所在方法的非final局部变量。
因为方法的局部变量位于栈上，只存在于该方法的生命期内。当一个方法结束，其栈结构被删除，局部变量成为历史。但是该方法结束之后，在方法内创建的内部类对象可能仍然存在于堆中!例如，如果对它的引用被传递到其他某些代码，并存储在一个成员变量内。正因为不能保证局部变量的存活期和方法内部类对象的一样长，所以内部类对象不能使用它们。



匿名内部类
顾名思义，没有名字的内部类。表面上看起来它们似乎有名字，实际那不是它们的名字。
当程序中使用匿名内部类时，在定义匿名内部类的地方往往直接创建该类的一个对象。匿名内部类的声明格式如下:

new ParentName(){

...// 内部类的定义

}

匿名内部类就是没有名字的内部类。什么情况下需要使用匿名内部类?如果满足下面的一些条件，使用匿名内部类是比较合适的:
一个类用于继承其他类或是实现接口，并不需要增加额外的方法，只是对继承方法的事先或是覆盖。
只用到类的一个实例 。
类在定义后马上用到。
类非常小(SUN推荐是在4行代码以下)
给类命名并不会导致你的代码更容易被理解。
在使用匿名内部类时，要记住以下几个原则:
匿名内部类不能有构造方法。
匿名内部类不能定义任何静态成员、静态方法。
匿名内部类不能是public,protected,private,static。
只能创建匿名内部类的一个实例。
一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类。
因匿名内部类为局部内部类，所以局部内部类的所有限制都对其生效。

注：一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类，没有类名，根据多态，我们使用其父类名。因他是局部内部类，那么局部内部类的所有限制都对其生效。匿名内部类是唯一一种无构造方法类。大部分匿名内部类是用于接口回调用的。匿名内部类在编译的时候由系统自动起名Out$1.class。如果一个对象编译时的类型是接口，那么其运行的类型为实现这个接口的类。因匿名内部类无构造方法，所以其使用范围非常的有限。当需要多个对象时使用局部内部类，因此局部内部类的应用相对比较多。匿名内部类中不能定义构造方法。如果一个对象编译时的类型是接口，那么其运行的类型为实现这个接口的类。

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");
}
});
}
}

内部类总结：
1.首先，把内部类作为外部类的一个特殊的成员来看待，因此它有类成员的封闭等级：private ,protected,默认(friendly),public
 它有类成员的修饰符:   static,final,abstract
2.非静态内部类nested inner class,内部类隐含有一个外部类的指针this,因此，它可以访问外部类的一切资源（当然包括private）
  外部类访问内部类的成员，先要取得内部类的对象,并且取决于内部类成员的封装等级。
  非静态内部类不能包含任何static成员.
3.静态内部类：static inner class,不再包含外部类的this指针，并且在外部类装载时初始化.
  静态内部类能包含static或非static成员.
  静态内部类只能访问外部类static成员.
  外部类访问静态内部类的成员，循一般类法规。对于static成员，用类名.成员即可访问，对于非static成员，只能
    用对象.成员进行访问
4.对于方法中的内部类或块中内部类只能访问块中或方法中的final变量。

类成员有两种static , non-static，同样内部类也有这两种

non-static 内部类的实例，必须在外部类的方法中创建或通过外部类的实例来创建(OuterClassInstanceName.new innerClassName(ConstructorParameter)),并且可直接访问外部类的信息,外部类对象可通过OuterClassName.this来引用
static 内部类的实例, 直接创建即可，没有对外部类实例的引用。
内部类不管static还是non-static都有对外部类的引用
non-static 内部类不允许有static成员

方法中的内部类只允许访问方法中的final局部变量和方法的final参数列表，所以说方法中的内部类和内部类没什麽区别。但方法中的内部类不能在方法以外访问，方法中不可以有static内部类

匿名内部类如果继承自接口,必须实现指定接口的方法,且无参数 

匿名内部类如果继承自类,参数必须按父类的构造函数的参数传递

为什么需要内部类
典型的情况是，内部类继承自某个类或实现某个接口，内部类的代码操作创建其他外围类的对象。所以你可以认为内部类提供了某种进入其外围类的窗口。使用内部类最吸引人的原因是:

每个内部类都能独立地继承自一个(接口的)实现，所以无论外围类是否已经继承了某个(接口的)实现，对于内部类都没有影响。如果没有内部类提供的可以继承多个具体的或抽象的类的能力，一些设计与编程问题就很难解决。从这个角度看，内部类使得多重继承的解决方案变得完整。接口解决了部分问题，而内部类有效地实现了"多重继承"。

内部类的优点是：内部类可以访问外部类的私有成员变量，而不需要new外部类的对象。

内部类又分为：静态内部类、匿名内部类、局部内部类、成员内部类。

静态内部类的应用场景是：只可以访问外部类的静态成员变量和静态成员方法。

成员内部类的应用场景是：它可以访问它的外部类的所有成员变量和方法，不管是静态的还是非静态的都可以。

局部内部类：像局部变量一样，不能被public, protected, private和static修饰。只能访问方法中定义的final类型的局部变量。

匿名内部类：匿名内部类就是没有名字的局部内部类，不使用关键字class, extends, implements, 没有构造方法。匿名内部类隐式地继承了一个父类或者实现了一个接口。匿名内部类使用得比较多，通常是作为一个方法参数。