Java内部类、Object类详细解析

最新推荐文章于 2026-08-31 20:35:45 发布

原创最新推荐文章于 2026-08-31 20:35:45 发布 · 203 阅读

本内容遵循CC 4.0 BY-SA版权协议

前言❤️❤️

hello hello💕，这里是洋不写bug~😄，欢迎大家点赞👍👍，关注😍😍，收藏🌹🌹
内部类，就是把一个类，定义到另一个类里面，这篇博客中提到的一些内部类，铁汁们以后几乎都用不到，这里只是了解下即可
比较重要的就是匿名内部类和Object类，日常用的比较多💪🐵

🎇个人主页：洋不写bug的博客
🎇所属专栏：Java学习之旅，从入门到进阶
🎇铁汁们对于Java的各种常用核心语法（不太常用的也有😆），都可以在上面的Java专栏学习，专栏正在持续更新中🐵🐵，有问题可以写在评论区或者私信我哦~

内部类主要有以下四种：

普通的内部类
静态内部类（内部类前添加了static关键字）
局部内部类（方法里面定义的类）
匿名内部类（局部内部类的特殊情况）

1，普通内部类

普通内部类如下所示，在内部类的方法中是可以访问外部类的属性的

package package9;

public class Outer {
    private int n = 10;

    public void printN(){
        System.out.println(n);
    }

    public void func(){
        Inner inner = new Inner();
        inner.printM();
    }

    class Inner{
        private int m = 20;

        public void printM(){
            System.out.println(m);
            System.out.println(n);
        }
    }
}

对于普通内部类来说，如果想在main方法中创建内部类实例，那就要先创建Outer的实例
如下所示：

public class Test {
    public static void main(String[] args) {

        Outer outer = new Outer();
        Outer.Inner inner = outer.new Inner();
    }
}

如果不创建Outer实例，直接尝试创建内部类的实例，是不行的（这个是因为main方法是static类型的，因为static方法中没有this，这个了解下即可）

或者也可以调用在Outer外部类中写的func()方法来创建内部类的实例

public class Test {
    public static void main(String[] args) {

        Outer outer = new Outer();
        outer.func();
    }
}

在这里插入图片描述

可能铁汁们会说这样写到底有啥用，其实这个代码也就是学习内部类和考试的时候写一下，以后很多年都不会写一次😅

2，静态内部类

静态内部类就是内部类加了static修饰，代码如下：

public class Outer {
    private int n = 10;

    public void printN(){
        System.out.println(n);
    }
    static class Inner{
        private int m = 20;

        public void printM(){
            System.out.println(m);
        }
    }
}

那在静态内布类中，是没办法访问外部类的非静态属性的，访问就会报错，如下图

当把n改为static类型时，静态内部类就可以访问了，如下所示：

另外，静态内部类也可以在static方法（main方法）中直接创建内部类实例，无需先创建Outer外部类的实例，如下所示：

3，局部内部类

局部内部类就是在方法的内部创建一个内部类，这样的写法就更小众了

这种就是直接在外部类中可以创建内部类实例，在其他类中是无法创建的，如下所示：

public class Outer {
   public void func(){
       class Inner{
           private int m = 10;
           public void printM(){
               System.out.println("m = " + m);
           }
       }
       Inner inner = new Inner();
       inner.printM();
   }
}

这个也只是了解下，在工作中写出局部内部类这种代码，是会被领导喷的😅

4，匿名内部类

前面三种内部类，工作中用的特别少，而匿名内部类在写代码时使用的频率是比较高的，这篇博客的重点就是匿名内部类

上篇接口博客提到了Comparator接口，需要重新写个比较器类，在比较类中重写compare方法，定义比较规则（先比较成绩，如果成绩相同再比较id，只有成绩和id都相等，才返回0），代码如下：

package package7;


public class Student{
    public int id;
    public String name;
    public double score;

    public Student(int id, double score, String name) {
        this.id = id;
        this.score = score;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public double getScore() {
        return score;
    }
}

package package7;

import java.util.Comparator;

public class StudentComparator implements Comparator<Student> {

    @Override
    public int compare(Student o1, Student o2) {
        if(o1.getScore() < o2.getScore()){
            return -1;
        }else if(o1.getScore() > o2.getScore()){
            return 1;
        }else{
            if(o1.getId() < o2.getId()){
                return -1;
            }else if(o1.getId() > o2.getId()){
                return 1;
            }
        }
        return 0;
    }
}

package package7;

public class Test {
    public static void main(String[] args) {
        Student s1 = new Student(1,90,"Mike");
        Student s2 = new Student(2,98,"Will");
        StudentComparator comparator = new StudentComparator();
        System.out.println(comparator.compare(s1,s2));
    }
}

像上面那样写还要额外创建个比较器类，比较麻烦，就可以通过匿名内部类把比较器类写在main方法中，会方便一些

代码如下所示：

package package7;

import java.util.Comparator;

public class Test {
    public static void main(String[] args) {
        Comparator<Student> comparator = new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                if (o1.getScore() < o2.getScore()) {
                    return -1;
                } else if (o1.getScore() > o2.getScore()) {
                    return 1;
                } else {
                    if (o1.getId() < o2.getId()) {
                        return -1;
                    } else if (o1.getId() > o2.getId()) {
                        return 1;
                    }
                }
                return 0;
            }
        };
        Student s1 = new Student(1,90,"Mike");
        Student s2 = new Student(2,98,"Will");
        System.out.println(comparator.compare(s1,s2));

    }
}

在这里插入图片描述

注意事项：

这里的new Comparator并不是创建实例，因为Comparator是接口，是创建不了实例的，这里是创建了一个没有名字（匿名）的内部类，这个类实现了Comparator接口
最外层的{ }定义这个匿名内部类的属性和方法，重写了compare方法，此处new出来就是就地定义的内部类的实例，注意最外层{ }后要加个分号
创建匿名内部类的实例，赋值给comparator引用，这个实例只能创建一次，后续就没办法再创建这个类的实例了
这样写对于一些只需要比较一次的场景，就比较省事，不需要再花费精力创建比较器类，直接创建个匿名内部类，这个实例用一次，以后就不再用了

5，Object类

Object类是标准库内置的类，是所以Java类的祖宗
所有的Java类都是直接或者间接继承自Object类，Object类中就提供了Java中所有类共性的属性方法（一些方法所有类都能使用）

就比如说toString()方法，是把对象转化为字符串，基所有的对象都有这样的需求

Object类有个使用频率很高的方法，就是equals()方法，那这个方法跟"=="有什么区别呢？
用==来比较的话，对于内置类型（int，char，double，long），就是直接比较是否相等，对于引用类型，就是比较引用是否相等

用当两个学生对象的id相等时，这两个对象就算相等的比较规则来比较
那用等号就不行了，因为等号只能比较引用是否相等
```
public class Test {
    public static void main(String[] args) {
        Student s1 = new Student(1,90,"Mike");
        Student s2 = new Student(1,90,"Mike");
        System.out.println(s1 == s2);
    }
}
```
想要按特定的比较规则来比较，就需要重写equals方法（equals方法如果不重写，直接用，那内部默认也是==），如下图

重写equals方法时，在Student类中按alt + enter键，选择重写方法，在里面选择重写equals方法，再按enter键，就会自动生成

在重写equals方法时，需要多考虑一些情况，多加一些判断（判断o是不是为null，是不是Student类型的），这些都通过以后，再进行id比较
```
 @Override
    public boolean equals(Object o) {
        if(o == null){
            return false;
        }
        if(this == o){
            return true;
        }
        if(!(o instanceof Student)){
            return false;
        }
        Student other = (Student) o;
        return this.id == other.id;
    }
```
重写之后，在main方法中测试一下，比较结果就是true
```
public class Test {
    public static void main(String[] args) {
        Student s1 = new Student(1,90,"Mike");
        Student s2 = new Student(1,90,"Mike");
        System.out.println(s1.equals(s2));
    }
}
```
结语

到这里的话，Java的基础语法部分，除了异常和String类，已经基本上解析完了（异常和String类后面会出两篇博客解析一下）
下篇博客中，就会从头到尾解析一个基础的图书管理系统，这个项目非常建议初学Java的铁汁来练手，可以巩固之前的基础知识💪💪💪