Java入门篇之内部类-CSDN博客

本文链接：https://blog.csdn.net/2201_75886757/article/details/134536057

本文详细介绍了Java中的内部类（包括静态内部类、实例内部类和匿名内部类），展示了它们的定义方式、访问权限以及在实际编程中的应用场景。作者强调了内部类的组织优势和常量的使用规则。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

本篇碎碎念：本篇没有碎碎念，想分享一段话：

你不笨，你只是需要时间，耐心就是智慧，不见得快就好，如果方向都不对，如果心术不正，如果德不配位，快就是对自己天分的一种浪费，不要急躁，慢慢来就很快。

-----董宇辉

今日份励志文案: To best is yet to come 未来可期

少年乘风，必会展翅翱翔！！！

内部类

可以将一个类的定义放在另一个类的定义内部，这就是内部类

内部类是一种非常有用的特性，因为它允许你把一些逻辑相关的类组织在一起，并控制位于内部的类的可视性，内部类和组合是完全不同的概念

博主认为，内部类可能看起来会比较奇怪(仅限个人想法)

创建内部类

创建内部类的方式就是把类的定义置于外围类的里面：

class OuterClass {
    public int date1 = 1;
    private int date2 = 2;
    public static int date3 = 3;

    //被static修饰的类就是静态内部类
    //static class InnerClass
    //没有被static修饰的叫做实例内部类或分非静态内部类
    class InnerClass {
        
        public int date4 = 4;
        private int date5 = 5;

        //常量是在编译的时候确定的
        //final常量
        //实例内部类中可以定义一个静态成员变量
        //但是这个变量必须是常量

        public static final int date6 = 6;
    }
}

下面的图片表示的是静态内部类

在输出System.out.println(date1)中报错，正确的写法下面也已经给出

在外部类中可以直接定义，但是在外部类之外就不可以，需要把外部类名加上

public void func() {
        //如果定义了一个方法，在方法里可以直接实例化静态内部类的对象
        InnerClass innerClass = new InnerClass();
        innerClass.test();
    }

下面的图片是实例内部类


        //常量是在编译的时候确定的
        //final常量
        //实例内部类中可以定义一个静态成员变量
        //但是这个变量必须是常量
        
        public static final int date6 = 6;

用final修饰，这是规定!!!

完整的举例代码


//静态内部类代码
//外部类
class OuterClass {
    public int date1 = 1;
    private int date2 = 2;
    public static int date3 = 3;

    //被static修饰的类就是静态内部类
    //没有被static修饰的叫做实例内部类或分非静态内部类
    static class InnerClass {
         //优先在自己的地盘找，找到就访问自己的
        public int date1 = 11111;
        public int date4 = 4;
        private int date5 = 5;
        //常量是在编译的时候确定的
        //final常量
        //实例内部类中可以定义一个静态成员变量
        //但是这个变量必须是常量
        public static final int date6 = 6;

        public void test() {
            //date是属于外部类对象的成员，得对外部类的引用访问date1

            OuterClass date = new OuterClass();
            System.out.println(date1);
            System.out.println(this.date1);
            System.out.println(this.date1);
            System.out.println(date.date1);
            System.out.println(date.date2);
            System.out.println(date4);
            System.out.println(date5);
            System.out.println(date6);
        }
    }

    public void func() {
        //如果定义了一个方法，在方法里可以直接实例化静态内部类的对象
        InnerClass innerClass = new InnerClass();
        innerClass.test();
    }

}
public class  demo9 {
    public static void main(String[] args) {
        OuterClass out = new OuterClass();
        out.func();

        //以下两种写法一样
        //第一张写法看着比较怪，就是通过外部类引用去调用的InnerClass
        //OuterClass.InnerClass a=out.new InnerClass();
        //OuterClass.InnerClass b=new OuterClass().new InnerClass();
        // a.test();
        //b.test();

        //如果在外部类之外就不可以直接实现了
       /* OuterClass.InnerClass innerClass = new OuterClass.InnerClass();
        innerClass.test();
        System.out.println("----我是分界线-----");
        OuterClass innerClass1=new OuterClass();
        innerClass1.func();
*/
    }
}

打印结果！

匿名内部类

interface InterFaceA{
    //定义接口
    public void func();
}
class TestA implements InterFaceA{

    @Override
    public void func() {
        System.out.println("重写的func");
    }
}
public class demo11 {
    public void func(){
        System.out.println("func");
    }
    public static void main(String[] args){
        TestA testA=new TestA();
        System.out.println("==========");
        //接口引用，引用这个东西，{}里面的就是匿名内部类
        InterFaceA a =new InterFaceA(){
            @Override
            public void func() {
                System.out.println("阿巴阿巴");
            }
        };
        a.func();
        testA.func();
    }
    public static void main1(String[] args){
        demo11 demo=new demo11();
        new demo11();//匿名对象，这个对象没有名字

        demo.func();//只实例化了一个demo对象
        demo.func();

        new demo11().func();//实例化了两个demo11对象
        new demo11().func();
        //如果说，以后的场景是只使用一次对象，那么就使用内部对象


    }
}