转载自：http://www.cnblogs.com/chenssy/p/3388487.html

内部类：在一个类的内部定义了一个类
内部类的作用：使用内部类的原因是：每个内部类都能独立地继承一个（接口）实现，所以无论是外围类是否已经继承了某个（接口）实现，对于内部类都没有影响。
使用内部类带来的好处：

• 内部类可以用多个实例，每个实例都有自己的状态信息，并且与其他外围对象的信息相互独立。
• 在单个外围类中，可以让多个内部类实现同一接口或者继承某一个类（包括抽象类），具体的实现可以不同。
• 创建内部类对象的时刻并不依赖与外围类对象的创建。
• 内部类并没有令人迷惑的“is - a ”关系，它是独立的
• 内部类提供了更好的封装，除了该外围类，其他类都不能访问。

内部类用法

成员内部类

成员内部类也是最普通的内部类，它是外围类的一个成员，所以他是可以无限制的访问外围类的所有成员变量和方法，包括private修饰的。外围类要访问内部列的成员属性和方法时，必须通过内部类的实例俩访问。

在成员内部类中：

• 成员内部类中不能存在private
• 成员内部类只有在创建了外围类才能创建内部类
  OuterClass outer = new OuterClass();
  OuterClass.InnerClass inner = outer.getInnerClass();
  OuterClass 属于外围类，InnerClass属于OuterClass的内部类。
• 推荐使用getxxx（）来获取成员内部类，尤其是该内部类的构造函数无参数时。

局部内部类

有这样一种内部类，它是嵌套在方法和作用域内的，对于这个类的使用主要是应用与解决比较复杂的问题，想创建一个类来辅助我们的解决方案，到那时又不希望这个类是公共可用的，所以就产生了局部内部类，局部内部类和成员内部类一样被编译，只是它的作用域发生了改变，它只能在该方法和属性中被使用，出了该方法和属性就会失效。

• 定义在方法中

      public class Parcel5 { 
          public Destionation destionation(String str){
               class PDestionation implements Destionation{ 
                    private String label; 
                    private PDestionation(String whereTo){
                              label = whereTo;
                     }
                     public String readLabel(){
                             return label; 
                     }
             }
             return new PDestionation(str);
         } 
            public static void main(String[] args) { 
              Parcel5 parcel5 = new Parcel5();
              Destionation d = parcel5.destionation("chenssy");
            }
      }
  

• 定义在作用域中
  public class Parcel6 {
  private void internalTracking(boolean b){
  if(b){
  class TrackingSlip{
  private String id;
  TrackingSlip(String s) {
  id = s;
  }
  String getSlip(){
  return id;
  }
  }
  TrackingSlip ts = new TrackingSlip("chenssy");
  String string = ts.getSlip();
  }
  }
  public void track(){
  internalTracking(true);
  }
  public static void main(String[] args) {
  Parcel6 parcel6 = new Parcel6();
  parcel6.track();
  }
  }

匿名内部类

      public class OuterClass {
                 public InnerClass getInnerClass(final int num,String str2){
                            return new InnerClass(){
                                       int number = num + 3;
                                       public int getNumber(){
                                                  return number;
                                        }
                              };        /* 注意：分号不能省 */
                   }

                public static void main(String[] args) {
                            OuterClass out = new OuterClass();
                            InnerClass inner = out.getInnerClass(2, "chenssy");
                            System.out.println(inner.getNumber());
                 }
      }
      interface InnerClass {
              int getNumber();
       }

注意：

• 匿名内部类是没有访问修饰符的
• new 匿名内部类，这个类首先要存在。
• 注意getInnerClass()方法的形参，第一个形参是用final修饰的，而第二个却没有。同时我们也发现第二个形参在匿名内部类中没有使用过，所以当所在方法的形参需要被匿名内部类使用，那么这个形参就必须为final。
• 匿名内部类是没有构造方法的。因为它连名字都没有何来构造方法。
• 匿名内部类必须实现一个父类或者一个接口。

Paste_Image.png
Paste_Image.png

静态内部类

使用static修饰的内部类我们称之为静态内部类。
静态内部类与非静态内部类之间存在一个最大的区别，我们知道非静态内部类在编译完成之后会隐含地保存着一个引用，该引用是指向创建它的外围内，但是静态内部类却没有。没有这个引用就意味着：

• 它的创建是不需要依赖于外围类的。
• 它不能使用任何外围类的非static成员变量和方法。