类中定义类/接口

目录

一、类内部定义类或接口有什么意义？

二、非静态内部类

2.1 非静态内部类如何访问？

2.1 代码demo

三、静态内部类

3.1 静态内部类可以new实例，因此不是类，这种说法对吗？

3.2 代码demo

四、局部内部类

4.1 局部内部类只能在作用域内使用

4.2 代码demo

五、匿名内部类

5.1 定义

5.2 格式

5.3 意义

5.4 代码demo

六、内部接口

6.1 代码demo

---

一、类内部定义类或接口有什么意义？

1、封装和组织性：通过在类的内部定义类或接口，可以将相关的功能和实现逻辑组织在一起，形成更加清晰和模块化的代码结构。这有助于提高代码的可读性和可维护性，并使代码更易于理解和使用。

2、访问权限控制：内部类可以访问外部类的私有成员和方法，这提供了更严格的访问控制和封装性。内部类可以直接访问外部类的私有成员，而外部类的其他类无法直接访问这些私有成员（可通过外部类中自定义的api访问），从而实现了更细粒度的访问权限控制。

3、实现细节隐藏：通过将一些实现细节封装在内部类中，可以隐藏这些细节并将其暴露给外部类的用户。这样可以实现信息隐藏和封装，使外部类的接口更加简洁和清晰，同时隐藏了一些复杂的实现细节。

4、实现接口和多重继承：内部类可以实现接口，从而为外部类提供多重继承的能力。通过内部类实现接口，可以在不引入多重继承的同时，为外部类提供额外的功能和行为。

5、回调和事件驱动：内部类常常用于实现回调和事件驱动的模式。通过将回调接口定义为内部类，并在适当的时候创建内部类的实例并传递给其他组件，可以实现灵活的回调机制和事件处理。

总的来说，类的内部定义类或接口可以提供更好的封装性、组织性和访问权限控制，并支持实现细节隐藏、接口实现、回调和事件驱动等重要的设计和实现模式。这样的设计选择可以提高代码的可维护性、可扩展性和可重用性，并促进更清晰、模块化和灵活的代码结构。

二、非静态内部类

2.1 非静态内部类如何访问？

外部类中写个api暴漏给其他类

2.1 代码demo

package com.demo;

/**
 * 非静态内部类
 */
public class OutClass {

    private String name = "jack";

    public class InnerClass {
        private int age = 23;

        public void print() {
            System.out.println("name = " + name + " age = " + age);
        }
    }

    /**
     * 给其他类提供个api
     */
    public void printOutClass() {
        InnerClass innerClass = new InnerClass();
        innerClass.print();
    }

    public static void main(String[] args) {
        new OutClass().printOutClass();//name = jack age = 23
        /**
         * 直接new 外部类().new 内部类()，就可以直接使用内部类
         */
        new OutClass().new InnerClass().print();//name = jack age = 23
    }
}

三、静态内部类

3.1 静态内部类可以new实例，因此不是类，这种说法对吗？

不完全正确。静态内部类是一种特殊的内部类，它是被静态修饰的内部类。

静态内部类与非静态内部类（也称为成员内部类）有所不同。它既是外部类的一个静态成员，具有静态特性，又是与外部类相互独立的类。因此，静态内部类是具有独立性的类，可以实例化访问其成员。

3.2 代码demo

package com.demo;

/**
 * 静态内部类
 */
public class OutClass {

    /**
     * 此处必须是静态的才能被静态内部类访问
     */
    private static String name = "jack";

    public static class StaticInnerClass {
        private int age = 23;

        public void print() {
            System.out.println("name = " + name + " age = " + age);
        }
    }

    private void printOutClass() {
        StaticInnerClass staticInnerClass = new StaticInnerClass();
        staticInnerClass.print();
    }

    public static void main(String[] args) {
        /**
         * new静态内部类的实例访问静态内部类的成员方法
         */
        OutClass.StaticInnerClass staticInnerClass = new OutClass.StaticInnerClass();
        staticInnerClass.print();//name = jack age = 23

        /**
         * 外部类中提供方法访问静态内部类
         */
        OutClass outClass = new OutClass();
        outClass.printOutClass();//name = jack age = 23
    }
}

四、局部内部类

4.1 局部内部类只能在作用域内使用

如下demo局部内部类只能在所在方法的作用域内使用，不能在外部方法之外访问。它的作用范围仅限于所在方法内部。

通过使用局部内部类，我们可以将相关的行为封装在方法内部，并实现一些特定的逻辑或功能。这有助于提高代码的可读性和模块化性，并将相关的功能组织在一起。

4.2 代码demo

package com.demo;

/**
 * 局部内部类
 */
public class OutClass {

    private String name = "jack";

    /**
     * 在方法中定义个局部内部类，局部内部类中成员可访问外部类的成员
     */
    public void printOutClass() {

        String sex = "男";

        class LocalInnerClass {
            private int age = 23;

            public void print() {
                System.out.println("name = " + name + " age = " + age + " sex = " + sex);
            }
        }

        LocalInnerClass localInnerClass = new LocalInnerClass();
        localInnerClass.print();
    }

    public static void main(String[] args) {
        new OutClass().printOutClass();//name = jack age = 23 sex = 男
    }
}

五、匿名内部类

5.1 定义

匿名内部类没有具体的类名，想要使用没有类名的类，代码中必须直接创建该类的实例，匿名内部类往往以对象的形式直接体现在代码中

5.2 格式

new 接口 / 抽象类( ) {
   重写api / 抽象方法

}

5.3 意义

通过使用匿名内部类，可以直接在需要的地方定义类的实现，而不必单独创建一个具名的类。这样可以使代码更加简洁，尤其在只需要使用一次且逻辑较简单的情况下。

5.4 代码demo

package com.demo;

/**
 * 匿名内部类
 */
public class OutClass {

    /**
     * 形式一：非静态内部类形式的匿名内部类
     */
    Runnable nmInnerClass = new Runnable() {
        @Override
        public void run() {
            System.out.println("hello nmInnerClass");
        }
    };

    /**
     * 形式二：静态内部类形式的匿名内部类
     */
    static Runnable staticNMInnerClass = new Runnable() {
        @Override
        public void run() {
            System.out.println("hello staticNMInnerClass");
        }
    };

    /**
     * 形式三：局部内部类形式的匿名内部类
     */
    public void outMethod() {
        Runnable staticNMInnerClass = new Runnable() {
            @Override
            public void run() {
                System.out.println("hello localNMInnerClass");
            }
        };
        staticNMInnerClass.run();
    }

    public void printOutClass() {
        nmInnerClass.run();
    }


    public static void main(String[] args) {
        new OutClass().printOutClass();//hello nmInnerClass
        OutClass.staticNMInnerClass.run();//hello staticNMInnerClass
        new OutClass().outMethod();//hello localNMInnerClass
    }
}

六、内部接口

6.1 代码demo

package com.demo;

/**
 * 内部接口
 */
public class OutClass {

    interface InnerInter {
        void print();
    }

    class InnerClass implements InnerInter {
        @Override
        public void print() {
            System.out.println("hello InnerClass");
        }
    }

    public static void main(String[] args) {
        /**
         * 使用方式一：创建实现内部接口重写内部接口中方法的匿名内部类
         */
        new OutClass.InnerInter() {
            @Override
            public void print() {
                System.out.println("hello innerInter");
            }
        }.print();//hello innerInter


        /**
         * 使用方式e二：直接在外部类中创建实现内部接口的内部类
         */
        new OutClass().new InnerClass().print();//hello InnerClass
    }

}