Java内部类知识点总结

定义：
放在一个类的内部的类我们就叫内部类。

作用：
内部类可以很好的实现隐藏：一般的类，是不允许有 private 与protected权限的，但内部类可以。
内部类拥有外部类的所有元素的访问权限。
可以实现多重继承。
可以避免修改接口而实现同一个类中两种同名方法的调用。

作用举例：
1：平时我们对类的访问权限，都是通过类前面的访问修饰符来限制的，一般的非内部类，是不允许有 private 与protected权限的，但内部类可以，所以我们能通过内部类来隐藏我们的信息。可以看下面的例子：

//接口
interface InterfaceTest
{
 void test();
}
//具体类
class Example {  
    private class InsideClass implements InterfaceTest
    {
         public void test()
         {
             System.out.println("这是一个测试");
         }
    }
    public InterfaceTest getIn()
    {
        return new InsideClass();
    }
}
//客户端程序
public class TestExample { 
 public static void main(String args[])
 {
    Example a=new Example();
    InterfaceTest a1=a.getIn();
    a1.test();
 }
}

从这段代码里面我们只知道Example的getIn()方法能返回一个InterfaceTest 实例但并不知道这个实例是怎么实现的。而且由于InsideClass 是private的，不看代码的话根本看不到这个具体类的名字，所以说它可以很好的实现隐藏。

2：可以无条件地访问外部类的所有元素

public class Outter {
   private String name="aa";
   private class Inner
   {
      public Inner()
      {
          System.out.println(name);
      }
   }
   public void test()
   {
    new InTest();
   }
   public static void main(String args[])
   {
       Outer test=new Outer();
       bb.test();
   }
}

name变量是在Outter里面定义的私有变量。这个变量在内部类中可以无条件地访问。

3：可以实现多重继承
它的存在使得Java的继承机制更加完善。大家都知道Java只能继承一个类，它的多重继承在我们没有学习内部类之前是用接口来实现的。但使用接口有时候有很多不方便的地方。比如我们实现一个接口就必须实现它里面的所有方法。而有了内部类就不一样了。它可以使我们的类继承多个具体类或抽象类。

//类一
class Example1 { 
   public String name()
   {
       return "aa";
   }
}
//类二
class Example2 { 
    public int age()
    {
        return 25;
    }
} 
//类三
public class MainExample
{
   private class test1 extends Example1
    {
        public String name()
        {
          return super.name();
        }
    }
    private class test2 extends Example2
    {
       public int age()
       {
         return super.age();
       }
    }
   public String name()
    {
    return new test1().name();
   }
   public int age()
   {
       return new test2().age();
   }
   public static void main(String args[])
   {
       MainExample mi=new MainExample();
       System.out.println("姓名:"+mi.name());
       System.out.println("年龄:"+mi.age());
   }
}

类三里面分别实现了两个内部类 test1,和test2 ，test1类又继承了Example1，test2继承了Example2，这样类三MainExample就拥有了Example1和Example2的方法和属性，也就间接地实现了多继承。

4：避免修改接口而实现同一个类中两种同名方法的调用。
如果一个类不仅要继承一个类，还要实现一个接口，可是继承的类和接口里面有两个同名的方法怎么办？怎么区分它们？？这就需要内部类了。看下面的代码：

//接口
interface Incrementable
{
 void increment();
}
//类 
class MyIncrement {
    public void increment()
    {
      System.out.println("Other increment()");
    }
    static void f(MyIncrement f)
    {
        f.increment();
    } 
}
public class Test extends MyIncrement
{
 private int i=0;
 private void incr()
 {
       i++;
       System.out.println(i);
 }
 private class Closure implements Incrementable
 {
      public void increment()
      {
        incr();
      }
 }
 Incrementable getCallbackReference()
 {
      return new Closure();
 }
}

用内部类来实现接口，这样就不会与外围类的方法冲突了。

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

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

• 成员内部类中不能定义静态成员。
• 成员内部类可以访问外部类的所有成员变量和方法，不管是静态的还是非静态的都可以。
• 在内部类里访问外部类的成员：Outerclass.this.member，如果内部类中没有与外部类同名的变量，则可以直接用变量名访问外部类变量。
• 在外部类的非静态方法里面创建成员内部类的实例：new Innerclass()。
• 在外部类的静态方法里面或外部类之外创建内部类的实例：(new Outerclass()).new Innerclass()。
• 内部类是一个编译时的概念，一旦编译成功，就会成为完全不同的两类。对于一个名为outer的外部类和其内部定义的名为inner的内部类。编译完成后出现outer.class和outer$inner.class两类。

2：局部内部类：作为方法内的一个局部变量存在，不能被public, protected, private和static修饰。

• 可以访问外部类的所有成员变量和方法，不管是静态的还是非静态的都可以。
• 只能访问方法内的final变量。
• 局部内部类在方法中定义，所以只能在方法中使用，即只能在方法当中生成局部内部类的实例并且调用其方法。

3：静态内部类(嵌套类)：（注意：前两种内部类与变量类似，所以可以对照参考变量）
如果你不需要内部类对象与其外围类对象之间有联系，那你可以将内部类声明为static。这通常称为嵌套类（nested class）。想要理解static应用于内部类时的含义，你就必须记住，普通的内部类对象隐含地保存了一个引用，指向创建它的外围类对象。然而，当内部类是static的时，就不是这样了。
嵌套类意味着：
- 要创建嵌套类的对象并不需要其外围类的对象。
- 不能从嵌套类的对象中访问非静态的外围类对象。
静态内部类中可以定义静态或者非静态的成员。
生成一个静态内部类不需要外部类成员，这是静态内部类和成员内部类的区别。静态内部类的对象可以直接生成：Outer.Inner in = new Outer.Inner()；而不需要通过生成外部类对象来生成。这样实际上使静态内部类成为了一个顶级类(正常情况下，你不能在接口内部放置任何代码，但嵌套类可以作为接口的一部分，因为它是static 的。只是将嵌套类置于接口的命名空间内，这并不违反接口的规则）

4：匿名内部类：匿名内部类就是没有名字的内部类。

什么情况下需要使用匿名内部类？如果满足下面的一些条件，使用匿名内部类是比较合适的：
- 只用到类的一个实例。
- 类在定义后马上用到。
- 类非常小（SUN推荐是在4行代码以下）
- 给类命名并不会导致你的代码更容易被理解。

在使用匿名内部类时，要记住以下几个原则：
- 匿名内部类不能有构造方法。
- 匿名内部类不能定义任何静态成员、方法和类。
- 匿名内部类不能是public,protected,private,static。
- 只能创建匿名内部类的一个实例。
- 一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类。
- 因匿名内部类为局部内部类，所以局部内部类的所有限制都对其生效。