Java笔记---内部类的使用

一、介绍

定义

将一个类的定义放在另一个类的定义的内部，放在内部的类就叫内部类，包裹在外面的就是外围类

种类

内部类分为4种：
1. 普通内部类
2. 局部内部类
3. 匿名内部类
4. 嵌套类

二、普通内部类

定义内部类

普通内部类的使用就和其定义一样，就是简单的将类定义放在另一个类定义中。如下：

public class OuterClass {    private int id = 10;    /**     - 内部类的定义     - @author johnnie     *     */    public class InnerClass {//      private static int age;                     // 普通内部类中是不能有 static 修饰的属性和方法的        /**         * 内部类方法，显示外围类的属性值         */        public void showOuterId(){            System.out.println("Outer id = " + id);        }    }}

就这样，就可以定义一个内部类，让其为我们服务了。

访问外围类的属性方法

内部类是可以访问外围类中的所有属性和方法的。其访问的方式有2中，以访问 id 来实例，如下：

System.out.println("Outer id = " + id);                     // 直接访问System.out.println("Outer id = " + OuterClass.this.id);     // 使用 OuterClass.this 来访问

同理，访问外围类的方法也是这样。
Q：为什么可以使用 OuterClass.this.id 这样的形式获取外围类的属性和方法呢？
A：因为在普通内部类中，可以使用 OuterClass.this 的语法来获取该内部类的外围类的引用。
[注：普通内部类隐式的包含着一个指向外围类对象的引用。]

内部类的实例化

既然定义了，自然是需要使用。那么内部类的实例化是怎样的呢？以往我们都是使用 new 来实例化的，那么是否可以按以前的方式来呢？如下：

InnerClass inner = new InnerClass();    // 编译器不通过

这样结果显示是不行的，编译器报错。那么怎么办？当然还是使用 new 来，但是使用的是其特殊语法”.new”，代码如下：

public static void main(String[] args) {    OuterClass out = new OuterClass();    // 内部类的实例化：需要特殊语法".new"    InnerClass inner = out.new InnerClass();    inner.showOuterId();} 

编译通过，运行结果：

三、局部内部类

定义

在方法和作用域中定义的内部类，称为局部内部类。

方法内定义内部类

注意，咱内部类的定义也是可以放在方法体内进行的。如下：

/** * 在方法体内定义内部类 */public void classInMethod () {    class InnerClass2 {                     // 此时不能加上访问权限修饰符        public void say () {            System.out.println("Hello");        }    }}

但是，这种情况下，就不能使用权限修饰符了。若写成 pubic class InnerClass2 { // … } 是会报错的

作用域内定义的内部类

/** * 作用域内定义内部类 */public void classInField (int x) {    // 在 if 作用域中定义内部类    if (x > 3) {        class InnerClass3 {            public void say () {                System.out.println("world");            }        }    }}

[记住：局部内部类是不能使用访问权限修饰符的]

三、匿名内部类

匿名内部类的使用

匿名内部类的使用如下所示：

/** * 匿名内部类案例 * @author johnnie * */public class AnonymouseClass {    // 内部接口    public interface Wrap {        public void info();    }    // 匿名内部类的示例    public Wrap getWrap(){        // 将返回值和表示该返回值的类定义结合        return new Wrap(){            private int id = 10;            @Override            public void info() {                System.out.println("id = " + id);            }        };    }    public static void main(String[] args) {        AnonymouseClass an = new AnonymouseClass();        Wrap wrap = an.getWrap();        wrap.info();    }}

匿名内部类直接访问外部参数

在 AnonymouseClass 中加入如下代码。
[AnonymouseClass]

private int age;public Wrap getWrap(final String name){    return new Wrap() {        @Override        public void info() {            System.out.println("name = " + name);   // 引用方法的参数            System.out.println("age = " + age);     // 使用外围类的属性        }    };}

通过案例，可以知道，匿名内部类和普通内部类一样，可以直接使用外围类的属性。但是，若是匿名内部类的方法要引用方法的参数，那么就必须得给参数加上 final 修饰。
Q：为什么要加 final 修饰？
A：因为虽然匿名内部类在方法的内部，但实际编译的时候，内部类编译成Outer.Inner,这说明内部类所处的位置和外部类中的方法处在同一个等级上，外部类中的方法中的变量或参数只是方法的局部变量，这些变量或参数的作用域只在这个方法内部有效。因为编译的时候内部类和方法在同一级别上，所以方法中的变量或参数只有为final，内部类才可以引用。

匿名内部类实现构造器的效果

Q：匿名内部类是不可能有构造器的，那么我们要是需要实现构造器的效果，该怎么办呢？
A：可以通过实例初始化操作来实现。

在 AnonymouseClass 中加入如下代码。
[AnonymouseClass]

public abstract class Base {    private int age;    public Base(int age) {        this.age = age;    }    public int getAge() {        return age;    }    public abstract void showAge();}// 实现实例初始化public Base getBase(int x){    return new Base(x) {                                    // 不需要加 final 修饰        @Override        public void showAge() {            System.out.println("My age is " + getAge());

// System.out.println(“x = ” + x); // 内部类方法直接使用参数，就需要加 final 修饰
}
};
}

这样，不仅实现了构造器的效果，而且也体现了一个差别：内部类方法直接引用外围类方法参数，那么该参数就得用 final 修饰，要是传给构造器，就不需要。
Q：Why？
A：参数传给构造器时，该参数并不会在匿名内部类中被直接使用。

五、嵌套类

定义

被 static 修饰的内部类就是嵌套类。示例代码如下：

/** - 嵌套类 - @author johnnie * */public class NestClass {    static class InnerClass {        private static int count = 0;        public void say () {            System.out.println("Hello, I'm a  nest class!");        }    }    public static void main(String[] args) {        // 使用普通 new 语法就可以进行实例化        InnerClass inner = new InnerClass();        inner.say();    }}

从上就可以看到嵌套类和普通内部类的区别：
1. 普通内部类的实例化需要使用 OuterClass.new 的特殊语法，而嵌套类直接使用普通的 new 语法就行。
Q：Why？
A：因为普通的内部类对象隐式的保存着一个指向创建它的外围类对象的引用，它们之间存在着联系。而嵌套类则不一样，它和外围类是断开的。
2. 普通内部类不能有 static 修饰的属性和方法，也不能有嵌套类，但是嵌套类可以。

六、小结

1. 内部类能访问外围类的所有方法和属性，但是外围类不可以访问内部类的方法和属性
   [实例]

   OuterClass.InnerClass.id; // 编译不通过
   OuterClass.InnerClass.this.id; // 编译不通过
   …

2. 方法内定义的内部类是不可以使用权限修饰符的。[请看局部内部类的案例]

3. 内部类是可以使用权限修饰符的，即可以使用 public、private、protected 来修饰。不要跟一个 xxx.java 文件中只能存在一个 public xxx 的类相混淆
   [Outer.class]

   public class Outer {
   //…
   }

   public class Outer2 {
   //…
   }
   这个是不行的。但是下面的是可以的
   [Outer.class]

   public class Outer {

   public class Inner {    // ...}

   }

4. 普通内部类中是不能有 static 修饰的属性和方法的

5. 虽然匿名内部类可以继承类，也可以实现接口，但是不能两者兼备。而且若是实现接口，也只能实现一个接口。[请自己试试]

内部类是一个很好的工具，使用场景也很多，比如：通过内部类实现一个接口，使得一个类具有一个接口的多个实现。等等。需要好好的理解与消化它。