Java内部类的使用

内部类

一般情况下，类和类之间是相互独立的，内部类的意思就是打破这种独立，让一个类成为另一个类的内部成员，和成员变量和成员方法同等级别。

为什么要使用内部类？

采用内部类这种技术，可以隐藏细节和内部结构，封装性更好，让程序的结构更加合理。

1、非静态内部类

public class OuterClass {

    //成员变量
    private String outerName;

    //成员方法
    public void display() {
        System.out.println("OuterClass display");
        System.out.println(outerName);
    }

    //内部类
    public class InnerClass {

        private String innerName;

        public void display() {
            System.out.println("InnerClass display");
            System.out.println(innerName);
        }

        public InnerClass() {
            innerName = "inner class";
        }
    }

    public static void main(String[] args) {
        OuterClass outerClass = new OuterClass();
        outerClass.display();

        /**
         * 这里不能直接new出InnerClass，因为这里的InnerClass是OuterClass的内部类
         * 需要借助OuterClass前缀，表明这是一个内部类
         */
        OuterClass.InnerClass innerClass = outerClass.new InnerClass();
        innerClass.display();
    }
}

运行结果：

outerName我们没有赋值所以为null，innerName我们赋值为inner class

总结：非静态内部类的使用就是将内部类当作外部类的一个成员变量或成员方法来使用，因为是非静态的所以必须依赖于外部类的对象才能调用，用法是和成员变量和成员方法一致的。

基本的内部类还可以在方法体中定义。

public class OuterClassTwo {

    //成员变量
    private String outerName;

    //成员方法
    public void display() {

       class InnerClass {
           public void print() {
               System.out.println("method inner class");
           }
       }
       InnerClass innerClass = new InnerClass();
       innerClass.print();
    }

    public static void main(String[] args) {
        OuterClassTwo outerClassTwo = new OuterClassTwo();
        outerClassTwo.display();
    }
}

运行截图：

2、静态内部类

静态内部类的构造不需要依赖于外部对象，类中的所有静态组件都不需要依赖于任何对象，可以直接通过类本身进行构造。

public class OuterClassThree {

    //成员变量
    private String outerName;

    //成员方法
    public void display() {
        System.out.println("OuterClassThree display");
        System.out.println(outerName);
    }

    public static class InnerClass {

        private String innerName;

        public InnerClass() {
            innerName = "inner class";
        }

        public void display() {
            System.out.println("InnerClass display");
            System.out.println(innerName);
        }
    }

    public static void main(String[] args) {
        OuterClassThree outerClassThree = new OuterClassThree();
        outerClassThree.display();
        OuterClassThree.InnerClass innerClass = new InnerClass();
        innerClass.display();
    }
}

运行截图：

3、匿名内部类（指的是没有名字的内部类，主要应用于接口的实现）

定义接口

public interface InterFace {

    public void test();
}

接口实现类

public class Implement implements InterFace{
    @Override
    public void test() {
        System.out.println("test");
    }
}

使用

public class Test {

    public static void main(String[] args) {

        //实现类
        InterFace interFace = new Implement();
        interFace.test();

        //匿名内部类，注意这里不是new的接口，接口是不能new的，这里new的是后面整个接口的实现类
        InterFace interFace1 = new InterFace() {
            @Override
            public void test() {
                System.out.println("test");
            }
        };
        interFace1.test();
    }
}

运行截图：

总结：使用匿名内部类就不用再使用实现类了，但缺点是耦合度太高。