Java语言基础：内部类-java语言基础教程培训

内部类，计算机面向对象程序设计概念。向对象程序设计中，可以在一个类的内部定义另一个类，这种类称为嵌套类(nested classes),它有两种类型，即静态嵌套类和非静态嵌套类。静态嵌套类使用很少，最重要的是非静态嵌套类，也即是被称作为内部类(inner)。内部类是JAVA语言的主要附加部分。内部类几乎可以处于一个类内部任何位置，可以与实例变量处于同一级，或处于方法之内，甚至是一个表达式的一部分。

1. 普通内部类

普通内部类的一个最简单的例子：

// 外部类     
class OutterClass {     
    // 内部类     
    public class InnerClass {     
        private int i = 0;     
        public int getInt(){     
            return i;     
        }     
    }     
    public void proc(){     
        InnerClass inClass = new InnerClass();     
        System.out.println(inClass.getInt());     
    }     
}     
      
public class Main {         
    public static void main(String[] args) {     
        OutterClass outClass = new OutterClass();     
        outClass.proc();     
    }     
}

外部类可以访问内部类的私有成员，内部类也可以访问外部类的私有成员：

// 外部类     
class OutterClass {     
    private int mOut = 10;     
    // 内部类     
    public class InnerClass {     
        private int mIn = 0;     
        public void printOutPrivate(){     
            // 直接打印外部类的成员     
            System.out.println(mOut);     
        }     
    }     
    public void printInPrivate(){     
        InnerClass inClass = new InnerClass();     
        // 直接打印内部类的私有成员     
        System.out.println(inClass.mIn);     
    }     
    public void printOutPrivate(){     
        InnerClass inClass = new InnerClass();     
        inClass.printOutPrivate();     
    }     
}     
      
public class Main {         
    public static void main(String[] args) {     
        OutterClass outClass = new OutterClass();     
        outClass.printInPrivate();     
        outClass.printOutPrivate();     
    }     
}

如果外部类的成员变量与内部类的成员变量名字相同，当内部类要访问外部类的该成员时，可以使用“OutClass.this.mem”来区分：

// 外部类     
class OutterClass {     
    private int mMem = 10;     
    // 内部类     
    public class InnerClass {     
        private int mMem = 0;     
        public void printOutPrivate(){     
            // 直接打印外部类的成员     
            System.out.println(OutterClass.this.mMem);     
        }     
    }     
}

要创建普通内部类，必须先创建相应的外部类：

// 外部类     
class OutterClass {     
    private int mMem = 10;     
    // 内部类     
    public class InnerClass {     
        private int mMem = 0;     
        public void printOutPrivate(){     
            // 直接打印外部类的成员     
            System.out.println(OutterClass.this.mMem);     
        }     
    }     
}     
      
public class Main {         
    public static void main(String[] args) {     
        OutterClass outClass = new OutterClass();     
       OutterClass.InnerClass inClass = outClass.new InnerClass();     
        inClass.printOutPrivate();     
    }     
}

也可以用下面的方式：

// 外部类     
class OutterClass {     
    private int mMem = 10;     
    // 内部类     
    public class InnerClass {     
        private int mMem = 0;     
        public void printOutPrivate(){     
            // 直接打印外部类的成员     
            System.out.println(OutterClass.this.mMem);     
        }     
    }     
    public InnerClass newInnerClass() {     
        return new InnerClass();     
    }     
}     
      
public class Main {         
    public static void main(String[] args) {     
        OutterClass outClass = new OutterClass();     
       OutterClass.InnerClass inClass = outClass.newInnerClass();     
        inClass.printOutPrivate();     
    }     
}

2. 静态内部类

普通内部类前面加上static修饰符，就成为静态内部类，静态内部类类似于C++的嵌套类，与普通内部类相比有如下区别：

静态内部类没有指向外部类的引用，外部类对于它来说更像一个名字空间。

普通内部类不能有静态成员，静态方法，或另一个静态内部类;而静态内部类可以有这一切。

静态内部类可以直接创建，不必先创建外部类：

// 外部类     
class OutterClass {     
    private int mMem = 0;     
    // 静态内部类     
    static public class InnerClass {     
        private int mMem = 0;     
        public void printOutPrivate(){     
            // 这是错误的     
            // System.out.println(OutterClass.this.mMem);     
        }     
    }     
    public void printInPrivate() {     
        InnerClass inClass = new InnerClass();     
        // 可以直接访问静态内部类的成员     
        System.out.println(inClass.mMem);     
    }     
}     
public class Main {         
    public static void main(String[] args) {     
        // 直接创建静态内部类     
        OutterClass.InnerClass inClass = new OutterClass.InnerClass();     
        inClass.printOutPrivate();     
    }     
}

从上面描述可以看出，静态内部类与一般类没有太大区别，只不过它是放在一个类的里面，这个类相当于它的名字空间，可以防止命名冲突。

3. 局部内部类

Java可以把一个类定义在一个方法里面，甚至是一个{}块里面，它的作用域就在这个块里面：

// 外部类     
class OutterClass {     
    public void testLocalInner() {     
        if (true)     
        {     
            class LocalInner {     
                public void proc() {     
                    System.out.println("hello");     
                }     
            }     
            // 可以创建使用     
            LocalInner localInner = new LocalInner();     
            localInner.proc();     
        }     
        // 错误：超出类定义的作用域     
        LocalInner localInner = new LocalInner();     
        localInner.proc();     
    }     
}

局部内部类的一般用途是实现某个接口，并作为这个接口传出方法被使用：

// 接口     
interface Talker {     
    public void Talk();     
}     
      
// 外部类     
class OutterClass {     
    public Talker getTalker() {     
        // 现实该接口的局部内部类     
        class SomeTalker implements Talker {     
            public void Talk() {     
                System.out.println("hello");     
            }     
        }     
        // 创建类实例并作为Talker返回     
        SomeTalker talker = new SomeTalker();     
        return talker;     
    }     
}     
      
public class Main {         
    public static void main(String[] args) {     
        OutterClass outClass = new OutterClass();     
        Talker talker = outClass.getTalker();     
        talker.Talk();     
    }     
}

4. 匿名内部类

匿名内部类的语法如下：

new InterfaceName(){......}; 或 new SuperclassName(){......};

它被认为是InterfaceName的实现者，或是SuperclassName的继承类，匿名内部类没有构建函数，如果SuperclassName有带参数的构造函数，必须在创建匿名内部类时带上这些参数，下面是匿名内部类最常见的使用场合：

// 接口     
interface Talker {     
    public void Talk();     
}     
      
// 外部类     
class OutterClass {     
    public void Talk(Talker talker) {     
        talker.Talk();     
    }     
}     
      
public class Main {         
    public static void main(String[] args) {     
        OutterClass outClass = new OutterClass();     
        // 直接生成一个匿名内部类     
        outClass.Talk(new Talker(){     
            public void Talk() {     
                System.out.println("hello");     
            }     
        });     
    }     
}

原文出处：http://blog.csdn.net/linzhengqun/archive/2011/03/24/6275586.aspx

【编辑推荐】