Android笔记——Android内部类

Java语言允许在类中再定义类，这种在其它类内部定义的类就叫内部类。内部类又分为：常规内部类、局部内部类、匿名内部类和静态嵌套类四种。我们内部类的知识在Android手机开发中经常用到。

一、常规内部类

所谓常规内部类，或者说内部类，指的就是除去后面三种之外的内部类（这算什么解释。。。）

 package maze;

 public class Test {
     class C
     {
         public void go(){
              System.out.println("我是C");
         }
     }
     public void show(){
         C c=new C();
         c.go();
     }
     public static void main(String[] args) {
         //System.out.println("Hello word");
         //A a=new A();
         //a.go();
         new Test().show();
     }
 }

在上面的例子里我们可以清晰的看到：

1. 内部类就像一个实例成员一样存在于外部类中。
2. 内部类可以访问外部类的所有成员就想访问自己的成员一样没有限制。
3. 内部类中的this指的是内部类的实例对象本身，如果要用外部类的实例对象就可以用类名.this的方式获得。
4. 内部类对象中不能有静态成员，原因很简单，内部类的实例对象是外部类实例对象的一个成员。

下面我们再小结一下内部类的创建方法：

1. 在外部类的内部，可以用 Inner inner = new Inner(); 方法直接创建
2. 在外部类外部，必须先创建外部类实例，然后再创建内部类实例，除了上面 Inner inner = new Outer().new Inner()的写法以外，还有 Outer outer = new Outer(); Inner inner = outer.new Inner();的写法

二、局部内部类

我们也可以把类定义在方法内部，这时候我们称这个类叫局部内部类。

 package methodinner;

 public class DuanZanShiChangZheng {
     public void noProblem(){
         System.out.println("我有急性短暂性精神障碍,杀人也没事");
     }
 }

 package methodinner;

 public class Test {
     public void driver(){
         System.out.println("我正在开车");
         class B extends DuanZanShiChangZheng{

         }
         new B().noProblem();
         //System.out.println("撞死人");
         System.out.println("一切恢复正常");//变成没事
     }
     public void show(){

     }
     public static void main(String[] args) {
           new Test().driver();

     }

 }

我们通过上面这里例子也可以看到下面几点：

1. 局部内部类的地位和方法内的局部变量的位置类似，因此不能修饰局部变量的修饰符也不能修饰局部内部类，譬如public、private、protected、static、transient等
2. 局部内部类只能在声明的方法内是可见的，因此定义局部内部类之后，想用的话就要在方法内直接实例化，记住这里顺序不能反了，一定是要先声明后使用，否则编译器会说找不到。
3. 局部内部类不能访问定义它的方法内的局部变量，除非这个变量被定义为final 。

是不是有点不好理解？关于为什么用final修饰以后就可以用了，我打算专门在番外篇里专门写一篇博客给你讲清楚，先记住吧。

三、匿名内部类

当我们把内部类的定义和声明写到一起时，就不用给这个类起个类名而是直接使用了，这种形式的内部类根本就没有类名，因此我们叫它匿名内部类。

 package anorymousinner;

 public abstract class Doctor implements Qinshou  {
     public void workInDay(){
         System.out.println("白天传授理论知识");
     }

 }

 package anorymousinner;

 public interface Qinshou {
     public void workInNight();
 }

 package anorymousinner;

 public class Douctor1 extends Doctor {
      public void workInNight(){
          System.out.println("晚上就教弹琴");
      }

 }

package anorymousinner;

public class Douctor2 extends Doctor {

    public void workInNight() {
        System.out.println("晚上，月黑风高夜，我要潜。。。我要潜心学习");
    }

}

package anorymousinner;

public class Test {

    public static void main(String[] args) {
        Douctor1 d1=new Douctor1();
        d1.workInDay();
        d1.workInNight();

        Douctor1 d2=new Douctor1();
        d2.workInDay();
        d2.workInNight();

        Doctor d3=new Doctor(){
            public void workInNight() {
                System.out.println("睡觉");
            }

        };
        d3.workInDay();
        d3.workInNight();

    }

}

竟然编译和运行都很正常，我们知道抽象类和接口肯定无法实例化的，因此刚才的例子肯定有点意思：

1. 匿名内部类用 new Doctor(){ … } 的方式把声明类的过程和创建类的实例的过程合二为一。
2. 匿名内部类可以是某个类的继承子类也可以是某个接口的实现类。

四、静态嵌套类

为了让你感觉舒服一些，我们也把最简单的内部类放在最后讲。

当一个内部类前面用static修饰时，我们称之为静态嵌套类或者说静态内部类。

上面的例子里其实我们已经看到过静态嵌套类了，下面我们再举一个例子：

因为静态嵌套类和其他静态方法一样只能访问其它静态的成员，而不能访问实例成员。因此静态嵌套类和外部类（封装类）之间的联系就很少了，他们之间可能也就是命名空间上的一些关联。上面例子中你需要注意的就是静态嵌套类的声明方法 new Outer.Nest() 连续写了两个类名，以至于我们都怀疑前面的Outer是个包名了，好在包名一般都小写的，要不还真分不清……

再强调一遍，内部类在Android中应用的非常多，理解和使用好显得蛮重要。