转载

JAVA基础（一）简单、透彻理解内部类和静态内部类

Java极客 | 作者 / 铿然一叶这是 Java极客的第 51 篇原创文章

1、内部类的作用

首先Java类的作用是功能内聚，将相近特性的功能内聚到一个类中，例如StringUtil类内聚String相关的功能，DateUtil类内聚Date相关的功能，那么内部类自然也有功能内聚的作用，与一般类不同的是，定义一个内部类通常意味者既要功能内聚，又要对外屏蔽可见性，即不希望外部可见，减少对外暴露的接口，这样从源码结构上来看，需要了解的类信息更少，更简洁。

2、为什么不用内部方法，而要用内部类

既然内部类是为了对外屏蔽可见性，那么内部类的功能不能直接用内部方法实现么？

内部类可以通过内部方法实现，但有的场景更适合用内部类来实现：

1.有一组相近的功能，可以内聚，归属到一个特性，如果都用方法实现，那么原来这个类的方法会很多。

2.需要继承或者实现某个接口，此时通过方法就无法做到。

3、内部类和静态类内部类的区别

从static关键字的一般用法出发很容易理解两者的区别：

1.static方法不能访问非static成员，同理静态内部类也一样。

2.非static方法能访问非static成员，同理内部类也一样。

3.非静态成员，需要通过类实例去访问，同理访问内部类也一样。

4.静态成员，可以通过类而非类实例来访问，同理访问静态内部类也一样。

因此，只要记住static关键字在一般类中的用法则可。下面看一个例子：

public class OuterClass {
    private String outerField;              // 非静态成员
    private static String staticOuterField; // 静态成员

    public InnerClass innerClass = new InnerClass();
    public StaticInterClass staticInterClass = new StaticInterClass();

    public class InnerClass {
        public void printFields() {
            System.out.println(outerField);         // 可访问非静态成员
            System.out.println(staticOuterField);   // 可访问静态成员
        }
    }

    public static class StaticInterClass {
        public void printFields() {
            System.out.println(outerField);         // 报错，不可访问非静态成员
            System.out.println(staticOuterField);   // 可访问静态成员
        }
    }

    public static void main(String[] args) {
        OuterClass outerClass = new OuterClass();
        // 类的访问有区别
        OuterClass.StaticInterClass staticInterClass = new OuterClass.StaticInterClass(); // 静态内部类可以直接通过类来访问
        OuterClass.InnerClass in = new OuterClass.InnerClass(); // 报错，内部类不能通过类去访问

        // 类实例的访问是一样的
        outerClass.innerClass.printFields();
        outerClass.staticInterClass.printFields();
    }
}
复制代码

4、何时使用内部类和静态类内部类

这个也可以结合static关键字的一般用法出发来考虑：

1.外部其他类需要如何访问内部类？例如是通过外部类的实例访问，还是通过外部类访问。如果通过类访问，那么就使用静态内部类，否则使用内部类。

2.是否需要访问类的非静态成员，如果需要就用内部类，否则用静态内部类。

5、内部类带来的增强能力-使得多重继承变得可能

在Java中不支持继承多个类，但是在一个类中可以定义多个内部类，不同的内部类又可以继承不同的类，这样就等于同一个类可以继承多个类。不过这样做跟使用组合也差不多了，都是在内部持有了一个新的类，而继承和组合的区别是继承可以继承一个抽象类，而组合不能。我们来看一个例子：

public class FlyingDog extends Dog {

//    Bird bird = new Bird();  这么用是组合
    InnerBird innerBird = new InnerBird(); // 这么用是继承

    public void fly() {
//        bird.fly();  这么用是组合
        innerBird.fly(); // 这么用是继承
    }

    // 实现了多重继承，不过就这个例子而言，使用多重继承跟使用组合没有啥区别。唯一区别是仅当父类是抽象类的时候只能使用继承。
    private class InnerBird extends Bird {
    }

    public static void main(String[] args) {
        FlyingDog flyingDog = new FlyingDog();
        flyingDog.fly();
        flyingDog.run();
    }
}

class Bird {
    public void fly() {
        System.out.println("I can fly");
    }
}

class Dog {
    public void run() {
        System.out.println("I can run");
    }
}
复制代码

end.

Java极客站点： javageektour.com/

原文 https://juejin.im/post/5e87f94bf265da47f0792ab8

正文到此结束