java 内部类笔记

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

内部类的种类：

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

package test;

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 dispaly");
            System.out.println(innerName);
        }

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

    public static void main(String[] args) {
        OuterClass outerClass = new OuterClass();
        outerClass.display();
//        错误的  不是一个独立的类，依赖于outerclass
//        InnerClass innerClass = new InnerClass();
        //非静态内部类的操作
        OuterClass.InnerClass innerClass = outerClass.new InnerClass();
        innerClass.display();
        //
    }
}

####### 为什么需要内部类呢？？？？？？？？

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

隐藏细节

1.2.局部内部类 基本的内部类还可以在一个方法体中定义

public class OuterClass {

    //成员变量
    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) {
        OuterClass outerClass = new OuterClass();
        outerClass.display();
    }
}

2. 静态内部类

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

public class OuterClass {

    //成员变量
    private String outerName;

    //成员方法
    public void display() {
        System.out.println("outerclass 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) {
        OuterClass outerClass = new OuterClass();
        outerClass.display();
        OuterClass.InnerClass innerClass = new InnerClass();
        innerClass.display();
    }
}
outerclass display
null
innerclass display
inner class

3.匿名内部类 （主要应用于接口的实现）

public class Test {
    public static void main(String[] args) {
        //实现类
        MyImplement myImplement = new MyImplement();
        myImplement.test();
        //匿名内部类
        MyInterface myInterface = new MyInterface() {
            @Override
            public void test() {
                System.out.println("test");
            }
        };
        myInterface.test();
    }
}

每个内部类都能够独立的继承自一个（接口）的实现，所以无论外围类是否已经继承了某个（接口的）实现，对于内部类并没有影响。更多的是内部类对多重继承的实现，使多重继承得到了保障，或者说更加便利。

（1）内部类可以有多个实例，每个实例都有自己的状态信息，并且与其外围类对象的信息相互独立。

（2）在单个外围类当中，可以让多个内部类以不同的方式实现同一接口。

（3）创建内部类对象的时刻并不依赖于外围类对象的创建。

（4）内部类没有让人感到迷惑的“is-a”关系；它就是一个独立的实体。