内部类学习

2023-11-09 14:54:52

一、内部类

1.1简介

在Java中，可以将一个类定义在另一个类里面或者一个方法里面，这样的类称为内部类。

广泛意义上的内部类一般来说包括这四种：成员内部类、局部内部类、匿名内部类和静态内部类。

1.2目的

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

为什么在Java中需要内部类？总结一下主要有以下四点：

　　1.每个内部类都能独立的继承一个接口的实现，所以无论外部类是否已经继承了某个(接口的)实现，对于内部类都没有影响。内部类使得多继承的解决方案变得完整，(内部类的存在使得Java的多继承机制变得更加完善。)

　　2.方便将存在一定逻辑关系的类组织在一起，又可以对外界隐藏。

　　3.方便编写事件驱动程序

　　4.方便编写线程代码

1.3种类

1.成员内部类

内部类像是外部类的一个成员，并且成员内部类可以访问外部类的所有成员变量和成员方法（包括private成员和静态成员）

当成员内部类拥有和外部类同名的成员变量或者方法时，会发生隐藏现象，即默认情况下访问的是成员内部类的成员。如果要访问外部类的同名成员，需要以下面的形式进行访问：

/**
 * @Author: 郜宇博
 * @Date: 2021/8/28 21:50
 */
public class InnerClass {
    private String outerName;
    public InnerClass(){
        outerName = "outerName";
    }
    /**
     * 成员内部类
     */
    public class InnerClassCreate{
        private String innerName;

        public InnerClassCreate() {
            innerName = "innerClass";
        }
        public void display(){
            System.out.println("InnerClass create");
            System.out.println(innerName);
            System.out.println(outerName);
        }
    }

    public static void main(String[] args) {
        InnerClass innerClass = new InnerClass();
        //使用外部类的对象创建内部类
        InnerClass.InnerClassCreate innerClassCreate = innerClass.new InnerClassCreate();
        innerClassCreate.display();

    }
}

2.局部内部类

局部内部类是定义在一个方法或者一个作用域里面的类，它和成员内部类的区别在于局部内部类的访问仅限于方法内或者该作用域内。

注意，局部内部类就像是方法里面的一个局部变量一样，是不能有public、protected、private以及static修饰符的。

/**
 * @Author: 郜宇博
 * @Date: 2021/8/28 21:50
 */
public class InnerClass {
    private String outerName;
    public InnerClass(){
        outerName = "outerName";
    }
    public void display(){
        class InnerClassCreate {
            private String innerName;

            public InnerClassCreate() {
                innerName = "innerName";
            }
            public void display(){
                System.out.println(innerName);
            }
        }
        InnerClassCreate innerClassCreate = new InnerClassCreate();
        innerClassCreate.display();
    }
    public static void main(String[] args) {
        InnerClass innerClass = new InnerClass();
        innerClass.display();

    }
}

3.匿名内部类

匿名内部类应该是平时我们编写代码时用得最多的，在编写事件监听的代码时使用匿名内部类不但方便，而且使代码更加容易维护。

实现接口时，可以在使用其他文件编写实现类，也可以在同一文件编写内部类，还可以使用匿名内部类

/**
 * MyInterfece接口
 */
public interface MyInterfece {
    public void test();
}

方法一：

public class MyImplementOne implements MyInterfece{
    @Override
    public void test() {
        System.out.println("在另外文件编写实现类--》实现接口");
    }

    public static void main(String[] args) {
        //方法一：使用外部文件编写实现类
        MyInterfece myImplementOne = new MyImplementOne();
        myImplementOne.test();
        
    }
}

方法二：

/**
 * MyInterfece接口
 *	内部类实现接口
 */
public interface MyInterfece {
    public void test();
    public class MyImplementTwo implements MyInterfece{
        @Override
        public void test() {
            System.out.println("采用内部类实现接口");
        }
    }

    public static void main(String[] args) {
        MyInterfece myImplementTwo = new MyImplementTwo();
        myImplementTwo.test();

    }
}

方法三：

/**
 *匿名内部类实现接口
*/
public static void main(String[] args) {
    //方法三：匿名内部类
    MyInterfece myImplementThird = new MyInterfece() {
        @Override
        public void test() {
            System.out.println("匿名内部类实现接口");
        }
    };
    myImplementThird.test();

}

4.静态内部类

静态内部类也是定义在另一个类里面的类，只不过在类的前面多了一个关键字static。

静态内部类是不需要依赖于外部类的(可以直接new)，这点和类的静态成员属性有点类似，并且它不能使用外部类的非static成员变量或者方法。

/**
 * @Author: 郜宇博
 * @Date: 2021/8/28 21:50
 */
public class InnerClass {
    private static String outerName;
    public InnerClass(){
        outerName = "outerName";
    }
    //静态内部类
    public static class StaticInnerClass{
        private String innerName;
        public StaticInnerClass(){
            innerName = "innerName";
        }
        public void display(){
            System.out.println(innerName);
            System.out.println(outerName);
        }

    }

    public static void main(String[] args) {
        InnerClass.StaticInnerClass staticInnerClass = new StaticInnerClass();
        staticInnerClass.display();

    }
}
//输出：innerName
//		null