Java 内部类获取外部变量内部类获取外部类对象

转载

蓝梦之翼 2023-06-17 20:35:22

文章标签 Java 内部类获取外部变量类对象内部类外部类 文章分类 Java 后端开发

一、内部类的定义

将一个类的定义放在另外一个类的内部，这就是内部类。内部类的特点，我们用一个例子来引出。

/**
 * Created by jay.zhou on 2018/2/23.
 */
public class Outer {
    private int year = 2018;
    class Inner{
        //static int size = 5; 报错
        public void show(){
            System.out.println(year);//内部类直接访问到外部类的成员变量
        }
    }

    public static void main(String[] args) {
        new Outer().new Inner().show();//运行结果：2018
    }
}

当外部类对象创建内部类对象的时候，内部类对象会秘密的捕获创建它的外部类对象的引用。

二、内部类捕获外部类对象的引用

普通的成员内部类对象的创建方法是，使用 " 外部类对象. new 内部类名()" ，比如 new Outter(). new Inner()。

既然当外部类对象创建内部类对象的时候，内部类对象会秘密的捕获那个创建它的外部类对象的引用。那在内部类中如何才能获取到这个引用呢？使用 “外部类类名.this”即可。

/**
 * Created by jay.zhou on 2018/2/23.
 */
public class Outer {
    private int year = 2018;
    class Inner{
        public Outer getOutter(){
            return Outer.this;
        }
    }

    public static void main(String[] args) {
        Outer outer = new Outer();
        Outer outer2 = outer.new Inner().getOutter();
        if(outer.equals(outer2)){
            System.out.println("内部类对象使用 外部类类名.this 返回 创建它的外部类对象的引用");
        }
    }
}

运行结果是：内部类使用外部类类名.this 返回创建它的外部类对象的引用。

这说明内部类能够使用"外部类类名.this"获取到创建它的外部类对象。

三、几种特殊的内部类

第一种是嵌套类。嵌套类是使用static 修饰的内部类。嵌套类的特点是：嵌套类的创建不需要外部类对象，并且嵌套类对象不能访问外部类对象的非静态成员。原因很简单，因为嵌套类对象不需要从外部类对象创建，因此也无法捕获到创建它的外部类对象的引用，自然就不能访问到属于外部类对象的普通成员变量和成员方法。嵌套的类名是 "外部类名.内部类名"，因此创建嵌套类对象的方法是： new Outter.Inner();

第二种是匿名内部类。匿名内部类就是没有名字的类。它通过new表达式返回的引用被自动向上转型为其父类。new 父｛重写｝; 这创建的是父的子类对象。 new 接口｛实现｝；这创建的是接口的实现类对象。并且匿名内部类对象它是没有构造函数的，因为它没有名字，通常可以使用“构造代码块”当作其构造函数。根据类的初始化过程，创建子类对象之前，它的父类对象必须先要被初始化完毕，因此，父类的构造函数将会被调用。

/**
 * Created by jay.zhou on 2018/2/23.
 */
public abstract class Annimal {
    public Annimal() {
        System.out.println("初始化一个动物");
    }

    public abstract void eat();
}

class Apply{
    public static void apply(Annimal annimal){
        annimal.eat();
    }

    public static void main(String[] args) {
        apply(new Annimal() {
            @Override
            public void eat() {
                System.out.println("某动物在吃东西");
            }
        });
    }
    /**
     * 运行结果：
     * 初始化一个动物
     * 某动物在吃东西
     */
}

当一个方法的参数是一个接口类型的时候，并且这个接口中的方法不超过三个，可以使用匿名内部类作为方法的实际参数进行传递。另外就是当某个类只需要使用一次的时候，也可以考虑使用匿名内部类。

四、内部类存在的意义

意义一：封装实现细节。下面用个简单的例子来演示一下。

/**
 * Created by jay.zhou on 2018/2/23.
 */
//电源接口有个方法是 发电
public interface PowerSource {
    void power();
}

//发电机,英语太差，只能用拼音了
class FaDianJi {
    //太阳能
    private class TaiYangNeng implements PowerSource {
        @Override
        public void power() {
            System.out.println("太阳能发电成功");
        }
    }

    //电池
    private class DianChi implements PowerSource {
        @Override
        public void power() {
            System.out.println("电池发电成功");
        }
    }

    /**
     * 发电机供电
     *
     * @param b 是否停电
     * @return  能够发电的工具
     */
    public PowerSource power(boolean b) {
        TaiYangNeng taiYangNeng = new TaiYangNeng();
        DianChi dianChi = new DianChi();
        if(b){
            return dianChi;
        }else{
            return taiYangNeng;
        }

    }

    public static void main(String[] args) {
        //有一个发电机
        FaDianJi faDianJi = new FaDianJi();
        //停电了
        PowerSource powerSource = faDianJi.power(true);
        powerSource.power();
        //没停电
        powerSource = faDianJi.power(false);
        powerSource.power();
    }
    /**
     * 运行结果：
     * 电池发电成功
     * 太阳能发电成功
     */
}

这个例子我想表达出，当某个方法将内部类对象“向上转型”为它的父类的时候，尤其转型成接口类型的时候，它的实现类将完全不可见。在"发电机"类的power(boolean b)方法中，有两个电源PowerSource的实现类，分别是“太阳能”对象和“电池”对象。此方法的返回值是一个接口类型，因此这两个对象在返回的时候将会自动发生“向上转型”。这样做的效果是，在我们只知道返回的是这个接口的实现类对象，无法知道这个类的具体实现。在应用的代码中，比如在主函数中，我们只能通过发电机拿到一个电源接口的实现类对象。但是这个电源是太阳能的，还是电池的，我们在客户端的代码上是看不到的，只知道发电机拿到的是一个电源的实现类对象。

内部类对象向上转型为它的接口形式的时候，在别的类中只能用到此接口的引用，无法知道其实现细节。

内部类间接支持“多重继承”

/**
 * Created by jay.zhou on 2018/2/23.
 */
public class A {
    public void show(){
        System.out.println("父类继承到的show方法");
    }
}

interface B{
     void show();
}

class C extends A {
    private class D implements B{
        @Override
        public void show() {
            System.out.println("内部类实现的show方法");
        }
    }
    public B getD(){
        return new D();
    }
}

class Apply2{
    public static void apply1(A a){
        a.show();
    }

    public static void apply2(B b){
        b.show();
    }

    public static void main(String[] args) {
        C c = new C();
        apply1(c);
        apply2(c.getD());
    }
    /**
     * 父类继承到的show方法
     * 内部类实现的show方法
     */
}

这个例子想说明：

类A有一个方法show()，接口B中也有一个抽象方法show()。类C继承了类A并且要求它实现B。

现在的问题在于，类C如果继承了A的话，那么它将会继承到A的show()方法，这将会自动实现B接口的show()。这并不是我们想要的，我们想要的是类C即要继承A的show()方法，又想自己实现B接口中的show()方法。那么类C使用内部类来实现接口，并且有一个方法将这个内部类对象，也就是这个实现类对象，向上转型为它的接口形式，作为方法的返回值，这个例子就是类C中getD()方法。现在的效果就是：类C的对象，既能作为它的父类A应用到客户端代码中，执行继承到的show()方法，也能作为接口B调用自己实现的show()方法。即继承到了父类的方法，又自己实现了接口中相同的方法。可谓是“既继承，又实现”，有了“多重继承”的感觉。