java内部类知识点的概要总结

java内部类知识点的概要总结

(以下总结基本摘自于java编程思想第四版)

内部类对象类型声明 ： 外部类名 . 内部内名

创建内部类对象 ：必须— 外部类对象（已经new过） . new 内部类对象名（）；

内部类可以继承其他类或实现接口，且能够很好的隐藏其实现细节，可以向上转型（所继承实现的类或接口）

可以在方法和作用域内定义内部类（如 if {} 作用域），

匿名内部类通过实例初始化实现构造（匿名内部类不可能有构造器（没有名字怎么写构造器），内部类可以有）

匿名内部类 new 基类名（基类构造器参数）{ 重写基类的方法 }； （分号是表达式的结束）；

匿名内部类要访问外部定义的对象则要求其参数引用是final的

---

静态内部类

当不需要内部类对象与其外围类对象之间有联系，那么可以将内部类声明为static（通常称为嵌套类）

创建嵌套类对象不需要其外围类对象

不能从嵌套类的对象中访问非静态的外围类对象

普通的内部类不能有static数据和static字段，也不能包含嵌套类，但嵌套类可以包含这些

嵌套类可以作为接口的一部分（放到接口中的任何类都自动的是public 和static的），甚至可以在内部类中实现其外围接口

多层嵌套（不是指嵌套类）的内部类 能透明的访问所有他所嵌入的外围类的所有成员

可以利用内部类实现 “多重继承”

---

内部类的继承

内部类的构造器必须链接到指向其外围类对象的引用

---

代码示例

package InnerClass;

interface Counter{
    int next();
}

public class LocalInnerClass {

    private int count = 0;
    Counter getCounter(final String name){
        //局部内部类
        class LocalCounter implements Counter{
            public LocalCounter(){
                System.out.println("LocalCounter()");
            }

            @Override
            public int next() {
                // TODO Auto-generated method stub
                System.out.println(name);
                return count++;
            }

        }

        return new LocalCounter();
    }

    Counter getCounter2(final String name){
        return new Counter(){

            //普通代码域，在类的每个对象创建的时候调用
            {
                System.out.println("Counter()");
            }

            @Override
            public int next() {
                // TODO Auto-generated method stub
                System.out.println(name);
                return count++;
            }

        };
    }

    public static void main(String args[]){
        LocalInnerClass localInnerClass = new LocalInnerClass();
        Counter 
            c1 = localInnerClass.getCounter("Local Inner"),
            c2 = localInnerClass.getCounter2("Anoymous Inner");

        for(int i = 0;i < 5;i++){
            System.out.println(c1.next());
        }

        for(int i = 0;i < 5;i++){
            System.out.println(c2.next());
        }
    }

}

结果：

withinner
Inner0
1
withinner
Inner0
1
Inner2
2
Inner1
2

---

当某个类继承了一个有内部类的外围类并定义了一个与那个内部类相同名字的内部类 则这两个内部类是没有任何影响的，都是完全独立的实体，没有覆盖效果。
局部内部类不能有访问说明符，因为他不是外围类的一部分，但他可以访问当前代码块内的常量，以及此外围类的所有成员。

package InnerClass;

interface Counter{
    int next();
}

public class LocalInnerClass {

    private int count = 0;
    Counter getCounter(final String name){
        //局部内部类
        class LocalCounter implements Counter{
            public LocalCounter(){
                System.out.println("LocalCounter()");
            }

            @Override
            public int next() {
                // TODO Auto-generated method stub
                System.out.println(name);
                return count++;
            }

        }

        return new LocalCounter();
    }

    Counter getCounter2(final String name){
        return new Counter(){

            //普通代码域，在类的每个对象创建的时候调用
            {
                System.out.println("Counter()");
            }

            @Override
            public int next() {
                // TODO Auto-generated method stub
                System.out.println(name);
                return count++;
            }

        };
    }

    public static void main(String args[]){
        LocalInnerClass localInnerClass = new LocalInnerClass();
        Counter 
            c1 = localInnerClass.getCounter("Local Inner"),
            c2 = localInnerClass.getCounter2("Anoymous Inner");

        for(int i = 0;i < 5;i++){
            System.out.println(c1.next());
        }

        for(int i = 0;i < 5;i++){
            System.out.println(c2.next());
        }
    }

}

结果：
LocalCounter()
Counter()
Local Inner
0
Local Inner
1
Local Inner
2
Local Inner
3
Local Inner
4
Anoymous Inner
5
Anoymous Inner
6
Anoymous Inner
7
Anoymous Inner
8
Anoymous Inner
9

---

内部类标识符
内部类也必须生成一个.class文件 其命名规则：外围类的名字，加上$ ， 再加上内部类的名字。匿名内部类 编译器会产生一个数字作为标识符

---

以上可能有一些我理解上的错误，如果发现还麻烦走过路过的指正一下