内部类

    内部类（Inner Classes的概念是在JDK1.1 版本中开始引入的。在Java中，允许在一个类（或方法、语句块的内部定义另一个类，后者称为内部类，有时也称为嵌套类（NestedClasses。内部类和外层封装它的类之间存在逻辑上的所属关系，一般只用在定义它的类或语句块之内，实现一些没通用意义的功能逻辑，在外部引用它时必须给出完整的名称。引入内部类的好处在于可使源代码更加清晰并减少类的命名冲突，就好比工厂制定内部通用的产品或工艺标准，可以取任何名称而不必担心和外界的标准同名，因为其使用范围不同。内部类是一个用的特征，因为它们允许将逻辑上同属性的类组合到一起，并在另一个类中控制一个类的可视性。

 

为什么引入内部类

 在我没查询网站之前感觉这个内部类真没什么大用途，了解后知道，java类只支持单继承，为了考虑方便所以在类引入了内部类的概念，内部类可以继承其他类，那这样就可以通过内部类继承来实现一个类的多继承了。

引用一段话：

java内部类有什么好处？为什么需要内部类？

1、举一个简单的例子，如果你想实现一个接口，但是这个接口中的一个方法和你构想的这个类中的一个方法的名称，参数相同，你应该怎么办？这时候，你可以建一个内部类实现这个接口。由于内部类对外部类的所有内容都是可访问的，所以这样做可以完成所有你直接实现这个接口的功能。

2、真正的原因是这样的，java中的内部类和接口加在一起，可以解决常被C++程序员抱怨java中存在的一个问题：没有多继承。实际上，C++的多继承设计起来很复杂，而java通过内部类加上接口，可以很好的实现多继承的效果。

 

内部类特点

（1）：嵌套类（内部类）可以体现逻辑上的从属关系。同时对于其他类可以控制内部类对外不可见等
（2）：外部类的成员变量作用域是整个外部类，包括嵌套类。但外部类不能访问嵌套类的private成员
（3）：逻辑上相关的类可以在一起，可以有效的实现信息隐藏。
（4）：内部类可以直接访问外部类的成员。可以用此实现多继承！
（5）：编译后，内部类也被编译为单独的类，不过名称为outclass$inclass的形式。
 

成员式内部类

先关注下代码，注意第4行又创建了一个类。

public class Outer {

         private int size;

 

         public class Inner {

                  private int counter = 10;

 

                  public void doStuff() {

                           size++;

                  }

         }

 

         public static void main(String args[]) {

                  Outer outer = new Outer();

                  Inner inner = outer.new Inner();

                  inner.doStuff();

                  System.out.println(outer.size);

                  System.out.println(inner.counter);

                  // System.out.println(counter); 编译错误，外部类不能访问内部类的private变量

         }

}

 

成员式内部类的基本规则
（1）：可以有各种修饰符，可以用4 种权限、static、final、abstract 定义（这点和普通的类是不同的）；
（2）：若有static限定，就为类级，否则为对象级。类级可以通过外部类直接访问；对象级需要先生成外部的对象后才能访问。
（3）：内外部类不能同名
（4）：非静态内部类中不能声明任何static成员
（5）：内部类可以互相调用，如下：

class A {

    class B { } //B、C间可以互相调用

    class C { }

}

 

在另一个外部类中使用非静态内部类中定义的方法时，要先创建外部类的对象，再创建与外部类相关的内部类的对象，再调用内部类的方法，如下所示：

 

注意第3、4两行。

public class Outer {

    public static void main(String args[]) {

        Outer2 outer = new Outer2();

        Outer2.Inner inner = outer.new Inner();

        inner.dostuff();

    }

}

 

class Outer2 {

    private int size;

 

    class Inner {

        public void dostuff() {

            size++;

        }

    }

}

 

static内部类相当于其外部类的static成分，它的对象与外部类对象间不存在依赖关系，因此可直接创建。示例如下：

注意第3行及10行。

public class Outer {

    public static void main(String args[]) {

        Outer2.Inner inner = new Outer2.Inner();

        inner.dostuff();

    }

}

 

class Outer2 {

    private static int size;

 

    static class Inner {

        public void dostuff() {

            size++;

            System.out.println("size=" + size);

        }

    }

}

 

 

由于内部类可以直接访问其外部类的成分，因此当内部类与其外部类中存在同名属性或方法时，也将导致命名冲突。所以在多层调用时要指明，如下所示：
注意第9行报错，还未查明原因。

public class Outer {

    private int size;

 

    public class Inner {

        private int size;

 

        public void dostuff(int size) {

            size++; // 本地的size;

            this.size;//内部类的size，此行编译时报错

            Outer.this.size++; // 外部类的size

        }

    }

}

 

本地内部类

本地类(Local class)是定义在代码块中的类.它们只在定义它们的代码块中是可见的.

本地类有几个重要特性:
（1）：仅在定义了它们的代码块中是可见的；
（2）：可以使用定义它们的代码块中的任何本地final变量；
（3）：本地类不可以是static的，里边也不能定义static成员。
（4）：本地类不可以用public、private、protected修饰，只能使用缺省的。
（5）：本地类可以是abstract的。

注意第4行，简单理解就是定义在方法里面的内部类为本地内部类。

public class Outer {

    public static final int TOTAL_NUMBER = 5;

    public int id = 123;

 

    public void t1() {

        final int a = 15;

        String s = "t1";

        class Inner {

            public void innerTest() {

                System.out.println(TOTAL_NUMBER);

                System.out.println(id);

                System.out.println(a);

                // System.out.println(s);不合法，只能访问本地方法的final变量

            }

        }

        new Inner().innerTest();

    }

 

    public static void main(String[] args) {

        Outer t = new Outer();

        t.t1();

    }

}

 

匿名内部类

匿名内部类是本地内部类的一种特殊形式，也就是没变量名指向这个类实例，而且具体的类实现会写在这个内部类里面。

匿名类的规则
（1）：匿名类没有构造方法；
（2）：匿名类不能定义静态的成员；
（3）：匿名类不能用4 种权限、static、final、abstract修饰；
（4）：只可以创建一个匿名类实例

注意 第8行，与本地内部类差不多，写法上有点区别。

public class Outer {

    public static final int TOTAL_NUMBER = 5;

    public int id = 123;

 

    public void t1() {

        final int a = 15;

        String s = "t1";

        new Aclass() {

            public void testA() {

                System.out.println(TOTAL_NUMBER);

                System.out.println(id);

                System.out.println(a);

                // System.out.println(s);不合法，只能访问本地方法的final变量

            }

        }.testA();

    }

 

    public static void main(String[] args) {

        Outer t = new Outer();

        t.t1();

    }

}

 

class Aclass {

    public void testA() {

    }

}

 

内部类规则小结

（1）：类名称只能用在定义过的范围中，除非用在限定的名称中。内部类的名称必须与所嵌套的类不同。
（2）：内部类可以被定义在方法中。这条规则较简单，它支配到所嵌套类方法的变量的访问。任何变量，不论是本地变量还是正式参数，如果变量被标记为final，那么，就可以被内部类中的方法访问。
（3）：内部类可以使用所嵌套类的类变量和实例变量以及所嵌套的块中的本地变量。
（4）：内部类可以被定义为abstract。
（5）：只有内部类可以被声明为private 或protected，以便防护它们不受来自外部类的访问。访问保护不阻止内部类使用其它类的任何成员，只要一个类嵌套另一个。
（6）：一个内部类可以作为一个接口，由另一个内部类实现。
（7）：被自动地声明为static的内部类成为顶层类。这些内部类失去了在本地范围和其它内部类中使用数据或变量的能力。
（8）：内部类不能声明任何static 成员；只有顶层类可以声明static 成员。因此，一个需求static成员的内部类必须使用来自顶层类的成员。