什么是包?

学习 Java 时,我们会写越来越多的类。比如学生管理系统里,可能有 Student、Teacher、Test1 等类。如果所有类都放在一起,数量一多,找起来就不太方便。

这时就可以使用**包(package)**来分类管理。刚开始可以把包理解为文件夹:把功能相近的类放在一起,后面查找和维护代码都会方便很多。

包名怎么写?

包名通常采用公司或个人域名反写 + 包的作用的形式,全部使用小写字母,尽量做到见名知意。

例如,我的域名是 homeofmjr.top,反过来就是 top.homeofmjr。如果想用一个包存放 Student、Teacher 这样的 JavaBean 类,就可以取名为:

纯文本
top.homeofmjr.domain

其中,top.homeofmjr 来自域名,domain 表示这个包主要用于放描述业务对象的类。

在 Java 文件的开头,可以使用 package 声明它属于哪个包:

java
package top.homeofmjr.domain;

public class Student {
}

包名加上类名,例如 top.homeofmjr.domain.Student,叫作这个类的全类名,也叫全限定类名。

为什么需要全类名呢?因为不同的包里可能都有一个叫 Student 的类。单看 Student,我们不知道指的是哪个;写成 top.homeofmjr.domain.Student,就能明确指定要使用的类了。

为什么需要 import?

假如我们想在其他包里使用刚才的 Student,可以直接写全类名:

java
top.homeofmjr.domain.Student s = new top.homeofmjr.domain.Student();

这样确实能写,但每次使用都要带上一长串包名,有点麻烦。

所以 Java 提供了 import 关键字。只要在文件开头导入这个类,后面就可以直接使用类名了:

java
import top.homeofmjr.domain.Student;

public class Test1 {
    public static void main(String[] args) {
        Student s = new Student();
    }
}

这样写就方便多了。这里的 import 可以理解为告诉 Java:后面出现的 Student,指的是 top.homeofmjr.domain 包中的那个类。

使用其他类时,可以先记住下面几条规则:

情况是否需要 import
使用同一个包中的类不需要
使用 java.lang 包中的类,例如 String、System不需要
使用其他包中的类通常需要导入,也可以直接写全类名
同时用到不同包中的同名类需要通过全类名区分其中的类

还要注意,包名看起来有层级,不代表它们是同一个包。例如 top.homeofmjr 和 top.homeofmjr.domain 是两个不同的包。

包名和文件夹是什么关系?

在 IntelliJ IDEA 中创建包时,我们可能只看到 top.homeofmjr.domain 这样连在一起的名字。但它对应的实际目录是一层套一层的。

假设 D:\Code\Java 是存放源代码的目录,那么文件结构可以是:

纯文本
D:\Code\Java
└── top
    └── homeofmjr
        └── domain
            └── Student.java

也就是说,先有 top 文件夹,里面是 homeofmjr,再往里面才是 domain。IDEA 只是为了方便查看,把这几层目录合并显示了。

final 关键字

final 可以用来修饰类、方法和变量。修饰的内容不同,作用也不一样:

final 修饰的内容作用
类不能再被其他类继承
方法不能被子类重写
变量只能赋值一次,之后不能再重新赋值

final 修饰方法

前面学习继承时,我们知道子类可以重写父类的方法。但如果父类不希望某个方法被重写,就可以用 final 修饰它。

java
class Fu {
    public final void show() {
        System.out.println("父类的show方法");
    }
}

class Zi extends Fu {
    @Override
    public void show() { // 编译报错:不能重写 final 方法
        System.out.println("子类的show方法");
    }
}

把这段代码放进 IDEA 后,子类的 show() 会出现红色波浪线。因为父类已经用 final 修饰了这个方法,子类就不能再重写它。

这里的代码是故意展示编译报错。如果删除子类中重写的 show(),Zi 仍然可以继承并调用父类的这个方法。

final 修饰类

如果 final 修饰的是一个类,那么这个类就不能再被继承了。

java
final class Fu {
}

class Zi extends Fu { // 编译报错:不能继承 final 类
}

这个例子和刚才类似:被 final 修饰的 Fu 已经不允许有子类,所以 Zi extends Fu 会直接报错。

final 修饰变量

如果 final 修饰的是变量,那么这个变量只能赋值一次。

java
public class Test1 {
    public static void main(String[] args) {
        final int a = 10;
        System.out.println(a);

        // a = 20; // 编译报错:不能再次赋值
    }
}

这里的 a 已经被赋值为 10,后面再写 a = 20 就会报错。

需要注意的是,final 变量不一定非得在声明的同时赋值,也可以先声明、后赋值;只是一旦完成赋值,就不能再改了。

在实际开发中,我们也会用常量来表示一些固定不变的值,例如最大人数、固定配置值等。这样不需要在代码里反复写数字,后期修改和阅读也更方便。

常量的命名一般采用全部大写的方式:

  • 只有一个单词:全部大写,例如 MAX。
  • 有多个单词:全部大写,单词之间用下划线隔开,例如 MAX_COUNT。

例如:

java
final int MAX_COUNT = 100;

如果希望一个类中的所有对象共用同一个常量,也经常把前面学过的 static 和 final 放在一起使用,例如 public static final int MAX_COUNT = 100;。

final 修饰基本类型和引用类型,有什么区别?

这里还有一个比较容易弄混的地方:final 修饰基本数据类型和引用数据类型时,具体不能修改的东西不同。

  • 基本数据类型:变量中保存的值不能再改变。例如 final int a = 10,不能再把 a 改成 20。
  • 引用数据类型:变量不能再指向其他对象,但当前对象内部的属性仍然可能被修改。

第二点怎么理解呢?我们可以创建两个 Student 对象来看一下:

java
public class Test1 {
    public static void main(String[] args) {
        final Student s1 = new Student();
        Student s2 = new Student();

        s1.name = "张三";
        s1.age = 18;
        System.out.println(s1.name + "," + s1.age);

        // s1 = s2; // 编译报错:s1 不能再指向另一个对象
    }
}

class Student {
    String name;
    int age;
}

输出:

纯文本
张三,18

我们把 s1 声明成 final Student s1,然后仍然可以修改 s1.name 和 s1.age。这是因为修改的是 s1 指向的对象里面的数据,并没有让 s1 指向别的对象。

但是如果写 s1 = s2,就不一样了。它想让 s1 改为指向 s2 所指向的对象,相当于重新给 s1 赋值,而 s1 已经被 final 修饰,所以会编译报错。

可以简单记成一句话:final 修饰引用变量,固定的是这个变量指向哪个对象,并不代表对象里面的所有属性都不能修改。

谢谢你读到这里。 ✧

聊两句

评论审核后显示

有疑问、补充,或者想交流一下,都可以写在这里。

评论区将在滚动到这里时加载。