包

在前面的代码中，我们把类和接口命名为Person、Student、Hello等简单名字。

在现实中，如果小明写了一个Person类，小红也写了一个Person类，现在，小白既想用小明的Person，也想用小红的Person，怎么办？

如果小军写了一个Arrays类，恰好JDK也自带了一个Arrays类，如何解决类名冲突？

在Java中，我们使用package来解决名字冲突。

Java定义了一种名字空间，称之为包：package。一个类总是属于某个包，类名（比如Person）只是一个简写，真正的完整类名是包名.类名。

例如：

小明的Person类存放在包ming下面，因此，完整类名是ming.Person；

小红的Person类存放在包hong下面，因此，完整类名是hong.Person；

小军的Arrays类存放在包mr.jun下面，因此，完整类名是mr.jun.Arrays；

JDK的Arrays类存放在包java.util下面，因此，完整类名是java.util.Arrays。

在定义class的时候，我们需要在第一行声明这个class属于哪个包。

小明的Person.java文件：

  1. package ming; // 申明包名ming
  3. public class Person {
  4. }

小军的Arrays.java文件：

  1. package mr.jun; // 申明包名mr.jun
  3. public class Arrays {
  4. }

在Java虚拟机执行的时候，JVM只看完整类名，因此，只要包名不同，类就不同。

包可以是多层结构，用.隔开。例如：java.util。

要特别注意：包没有父子关系。java.util和java.util.zip是不同的包，两者没有任何继承关系。

没有定义包名的class，它使用的是默认包，非常容易引起名字冲突，因此，不推荐不写包名的做法。

我们还需要按照包结构把上面的Java文件组织起来。假设以package_sample作为根目录，src作为源码目录，那么所有文件结构就是：

  1. package_sample
  2. └─ src
  3.     ├─ hong
  4.     │  └─ Person.java
  5.     │  ming
  6.     │  └─ Person.java
  7.     └─ mr
  8.        └─ jun
  9.           └─ Arrays.java

即所有Java文件对应的目录层次要和包的层次一致。

编译后的.class文件也需要按照包结构存放。如果使用IDE，把编译后的.class文件放到bin目录下，那么，编译的文件结构就是：

  1. package_sample
  2. └─ bin
  3.    ├─ hong
  4.    │  └─ Person.class
  5.    │  ming
  6.    │  └─ Person.class
  7.    └─ mr
  8.       └─ jun
  9.          └─ Arrays.class

包作用域

位于同一个包的类，可以访问包作用域的字段和方法。不用public、protected、private修饰的字段和方法就是包作用域。例如，Person类定义在hello包下面：

  1. package hello;
  3. public class Person {
  4.     // 包作用域:
  5.     void hello() {
  6.         System.out.println("Hello!");
  7.     }
  8. }

Main类也定义在hello包下面：

  1. package hello;
  3. public class Main {
  4.     public static void main(String[] args) {
  5.         Person p = new Person();
  6.         p.hello(); // 可以调用，因为Main和Person在同一个包
  7.     }
  8. }

import

在一个class中，我们总会引用其他的class。例如，小明的ming.Person类，如果要引用小军的mr.jun.Arrays类，他有三种写法：

第一种，直接写出完整类名，例如：

  1. // Person.java
  2. package ming;
  4. public class Person {
  5.     public void run() {
  6.         mr.jun.Arrays arrays = new mr.jun.Arrays();
  7.     }
  8. }

很显然，每次写完整类名比较痛苦。

因此，第二种写法是用import语句，导入小军的Arrays，然后写简单类名：

  1. // Person.java
  2. package ming;
  4. // 导入完整类名:
  5. import mr.jun.Arrays;
  7. public class Person {
  8.     public void run() {
  9.         Arrays arrays = new Arrays();
  10.     }
  11. }

在写import的时候，可以使用*，表示把这个包下面的所有class都导入进来（但不包括子包的class）：

  1. // Person.java
  2. package ming;
  4. // 导入mr.jun包的所有class:
  5. import mr.jun.*;
  7. public class Person {
  8.     public void run() {
  9.         Arrays arrays = new Arrays();
  10.     }
  11. }

我们一般不推荐这种写法，因为在导入了多个包后，很难看出Arrays类属于哪个包。

还有一种import static的语法，它可以导入可以导入一个类的静态字段和静态方法：

  1. package main;
  3. // 导入System类的所有静态字段和静态方法:
  4. import static java.lang.System.*;
  6. public class Main {
  7.     public static void main(String[] args) {
  8.         // 相当于调用System.out.println(…)
  9.         out.println("Hello, world!");
  10.     }
  11. }

import static很少使用。

Java编译器最终编译出的.class文件只使用完整类名，因此，在代码中，当编译器遇到一个class名称时：

  • 如果是完整类名，就直接根据完整类名查找这个class；

  • 如果是简单类名，按下面的顺序依次查找：

    • 查找当前package是否存在这个class；

    • 查找import的包是否包含这个class；

    • 查找java.lang包是否包含这个class。

如果按照上面的规则还无法确定类名，则编译报错。

我们来看一个例子：

  1. // Main.java
  2. package test;
  4. import java.text.Format;
  6. public class Main {
  7.     public static void main(String[] args) {
  8.         java.util.List list; // ok，使用完整类名 -> java.util.List
  9.         Format format = null; // ok，使用import的类 -> java.text.Format
  10.         String s = "hi"; // ok，使用java.lang包的String -> java.lang.String
  11.         System.out.println(s); // ok，使用java.lang包的System -> java.lang.System
  12.         MessageFormat mf = null; // 编译错误：无法找到MessageFormat: MessageFormat cannot be resolved to a type
  13.     }
  14. }

因此，编写class的时候，编译器会自动帮我们做两个import动作：

  • 默认自动import当前package的其他class；

  • 默认自动import java.lang.*。

注意：自动导入的是java.lang包，但类似java.lang.reflect这些包仍需要手动导入。

如果有两个class名称相同，例如，mr.jun.Arrays和java.util.Arrays，那么只能import其中一个，另一个必须写完整类名。

最佳实践

为了避免名字冲突，我们需要确定唯一的包名。推荐的做法是使用倒置的域名来确保唯一性。例如：

  • org.apache
  • org.apache.commons.log
  • com.liaoxuefeng.sample

子包就可以根据功能自行命名。

要注意不要和java.lang包的类重名，即自己的类不要使用这些名字：

  • String
  • System
  • Runtime
  • …

要注意也不要和JDK常用类重名：

  • java.util.List
  • java.text.Format
  • java.math.BigInteger
  • …

编译和运行

假设我们创建了如下的目录结构：

  1. work
  2. ├── bin
  3. └── src
  4.     └── com
  5.         └── itranswarp
  6.             ├── sample
  7.             │   └── Main.java
  8.             └── world
  9.                 └── Person.java

其中，bin目录用于存放编译后的class文件，src目录按包结构存放Java源码，我们怎么一次性编译这些Java源码呢？

首先，确保当前目录是work目录，即存放src和bin的父目录：

  1. $ ls
  2. bin src

然后，编译src目录下的所有Java文件：

  1. $ javac -d ./bin src/**/*.java

命令行-d指定输出的class文件存放bin目录，后面的参数src/**/*.java表示src目录下的所有.java文件，包括任意深度的子目录。

注意：Windows不支持**这种搜索全部子目录的做法，所以在Windows下编译必须依次列出所有.java文件：

  1. C:\work> javac -d bin src\com\itranswarp\sample\Main.java src\com\itranswarp\world\Persion.java

如果编译无误，则javac命令没有任何输出。可以在bin目录下看到如下class文件：

  1. bin
  2. └── com
  3.     └── itranswarp
  4.         ├── sample
  5.         │   └── Main.class
  6.         └── world
  7.             └── Person.class

现在，我们就可以直接运行class文件了。根据当前目录的位置确定classpath，例如，当前目录仍为work，则classpath为bin或者./bin：

  1. $ java -cp bin com.itranswarp.sample.Main 
  2. Hello, world!

练习

请按如下包结构创建工程项目：

  1. oop-package
  2. └── src
  3.     └── com
  4.         └── itranswarp
  5.             ├── sample
  6.             │   └── Main.java
  7.             └── world
  8.                 └── Person.java

从包 - 图1下载练习：Package结构 （推荐使用IDE练习插件快速下载）

小结

Java内建的package机制是为了避免class命名冲突；

JDK的核心类使用java.lang包，编译器会自动导入；

JDK的其它常用类定义在java.util.*，java.math.*，java.text.*，……；

包名推荐使用倒置的域名，例如org.apache。

读后有收获可以支付宝请作者喝咖啡：

包 - 图2