内部类的使用

内部类

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

1、非静态内部类

package com.ycz.test;

/**
 * @Description:
 * @Author: Alex
 * @Date 2022-07-06-15:53
 * @Version: V1.0
 **/
public class OuterClass {
    private String outerName;

    public void display(){
        System.out.println("OtherClass display");
        System.out.println(outerName);
    }
    public class  InnerClass{
        private String innerName;
        public void display(){
            System.out.println("innerClass");
            System.out.println(innerName);
        }
        public InnerClass(){
            innerName  = "inner Class";
        }
    }


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

        OuterClass.InnerClass innerClass = outerClass.new InnerClass();
        innerClass.display();
    }

}

结果：

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

为什么使用内部类

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

方法内部类

package com.ycz.test;

/**
 * @Description:
 * @Author: Alex
 * @Date 2022-07-06-16:08
 * @Version: V1.0
 **/
public class OuterClass2 {
    private String outerName;

    public void display(){
        class InnerClass2{
            public void display(){
                System.out.println("method inner class");
            }
        }
        InnerClass2 innerClass2 = new InnerClass2();
        innerClass2.display();
    }

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


}

结果：

静态内部类

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

package com.ycz.test;

/**
 * @Description:
 * @Author: Alex
 * @Date 2022-07-06-16:11
 * @Version: V1.0
 **/
public class OuterClassStatic {
    private String outerName;

    public void display(){
        System.out.println("outer class display");
    }

    public static class InnerClassStatic{
        private String innerName;
        public InnerClassStatic(){
            innerName = "inner class";
        }
        public void display(){
            System.out.println("inner class display");
            System.out.println(innerName);
        }
    }

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

        InnerClassStatic innerClassStatic = new InnerClassStatic();
        innerClassStatic.display();
    }
}

结果：

匿名内部类

package com.ycz.test;

/**
 * @Description:
 * @Author: Alex
 * @Date 2022-07-06-16:17
 * @Version: V1.0
 **/
public interface MyInterface {
    public void test();
}

package com.ycz.test;

/**
 * @Description:
 * @Author: Alex
 * @Date 2022-07-06-16:17
 * @Version: V1.0
 **/
public class MyImplement implements MyInterface{
    @Override
    public void test() {
        System.out.println("test1");
    }
}

package com.ycz.test;

/**
 * @Description:
 * @Author: Alex
 * @Date 2022-07-06-16:29
 * @Version: V1.0
 **/
public class Test {
    public static void main(String[] args) {
        MyInterface myInterface = new MyImplement();
        myInterface.test();


		//这个就是匿名内部类
        MyInterface myInterface1 = new MyInterface() {
            @Override
            public void test() {
                System.out.println("test2");
            }
        };

        myInterface1.test();

    }
}

结果：