# java 中的包以及如何使用它们

> 原文： [https://beginnersbook.com/2013/03/packages-in-java/](https://beginnersbook.com/2013/03/packages-in-java/)

顾名思义，包是类，接口和其他包的包（组）。在 java 中，我们使用包来组织我们的类和接口。我们在 Java 中有两种**类型的包：内置包和我们可以创建的包（也称为用户定义包）。在本指南中，我们将了解什么是包，什么是 java 中的用户定义包以及如何使用它们。**

在 java 中我们有几个内置包，例如当我们需要用户输入时，我们导入一个这样的包：

```java
import java.util.Scanner
```

这里：
→ `java`是顶级包
→ `util`是子包
→ `Scanner`是一个类是存在于子包`util`中。

在我们看到如何在 java 中创建用户定义的包之前，让我们看看使用包的优点。

## 在 Java 中使用包的优点

这些是您应该在 Java 中使用包的原因：

*   **可重用性**：在 java 中开发项目时，我们常常觉得在我们的代码中我们一再写的东西很少。使用包，您可以在包内部以类的形式创建这样的东西，并且只要您需要执行相同的任务，只需导入该包并使用该类。
*   **更好的组织**：同样，在我们有数百个类的大型 java 项目中，总是需要将相似类型的类分组到一个有意义的包名中，这样您就可以更好地组织项目了。需要一些东西，你可以快速找到它并使用它，这提高了效率。
*   **名称冲突**：我们可以在不同的包中定义两个具有相同名称的类，以避免名称冲突，我们可以使用包

## Java 中的包类型

正如本指南开头所提到的，我们在 java 中有两种类型的包。

1）用户定义的包：我们创建的包称为用户定义的包。

2）内置包：已经定义的包如`java.io.*`，`java.lang.*`等被称为内置包。

我们已经讨论了内置包，可以借助示例讨论用户定义的包。

## 示例 1：Java 包

我在包名`letmecalculate`中创建了一个类`Calculator`。要在包中创建类，请在程序的第一个语句中声明包名。一个类只能有一个包声明。
在包`letmecalculate`内创建的`Calculator.java`文件

```java
package letmecalculate;

public class Calculator {
   public int add(int a, int b){
	return a+b;
   }
   public static void main(String args[]){
	Calculator obj = new Calculator();
	System.out.println(obj.add(10, 20));
   }
}

```

现在让我们看看如何在另一个程序中使用此包。

```java
import letmecalculate.Calculator;
public class Demo{
   public static void main(String args[]){
	Calculator obj = new Calculator();
	System.out.println(obj.add(100, 200));
   }
}
```

要使用类`Calculator`，我已导入包`letmecalculate`。在上面的程序中，我将包导入为`letmecalculate.Calculator`，这只导入了`Calculator`类。但是如果你在包`letmecalculate`中有几个类，那么你可以像这样导入包，以使用这个包的所有类。

```java
import letmecalculate.*;
```

## 示例 2：在导入另一个包时在包内创建一个类

正如我们所看到的，包声明和包导入都应该是 java 程序中的第一个语句。让我们看看当我们在导入另一个包时在包内创建一个类时应该是什么顺序。

```java
//Declaring a package
package anotherpackage;
//importing a package
import letmecalculate.Calculator;
public class Example{
   public static void main(String args[]){
	Calculator obj = new Calculator();
	System.out.println(obj.add(100, 200));
   }
}
```

所以这种情况下的顺序应该是：
→包的声明
→包的导入

## 示例 3：导入类时使用完全限定名称

您可以使用完全限定名称来避免`import`语句。让我们看一个例子来理解这个：

`Calculator.java`

```java
package letmecalculate;
public class Calculator {
   public int add(int a, int b){
	return a+b;
   }
   public static void main(String args[]){
	Calculator obj = new Calculator();
	System.out.println(obj.add(10, 20));
   }
}
```

`Example.java`

```java
//Declaring a package
package anotherpackage;
public class Example{
   public static void main(String args[]){
        //Using fully qualified name instead of import
	letmecalculate.Calculator obj = 
		new letmecalculate.Calculator();
	System.out.println(obj.add(100, 200));
   }
}
```

在`Example`类中，我使用了诸如`package_name.class_name`之类的完全限定名来创建它的对象，而不是导入包。您可能还想阅读： [Java 中的静态导入](https://beginnersbook.com/2013/05/java-static-import/)

## Java 中的子包

另一个包中的包称为子包。例如，如果我在`letmecalculate`包中创建一个包，那么它将被称为子包。

假设我在`letmecalculate`中创建了另一个包，子包名称是`multiply`。所以如果我在这个子包中创建一个类，它应该在开头有这个包声明：

```java
package letmecalculate.multiply;
```

Multiplication.java

```java
package letmecalculate.multiply;
public class Multiplication {
	int product(int a, int b){
		return a*b;
	}
}
```

现在如果我需要使用这个`Multiplication`类，我必须像这样导入包：

```java
import letmecalculate.multiply;
```

或者我可以使用这样的完全限定名称：

```java
letmecalculate.multiply.Multiplication obj = 
     new letmecalculate.multiply.Multiplication();

```

## 要记住的要点：

1.  有时可能会发生类名冲突。例如：假设我们有两个包`abcpackage`和`xyzpackage`，两个包都有一个同名的类，让它为`JavaExample.java`。现在假设一个类导入这两个包，如下所示：

```java
import abcpackage.*;
import xyzpackage.*;
```

这将抛出编译错误。要避免此类错误，您需要使用我上面显示的完全限定名称方法。例如

```java
abcpackage.JavaExample obj = new abcpackage.JavaExample();
xyzpackage.JavaExample obj2 = new xyzpackage.JavaExample();
```

这样就可以避免导入包语句并避免名称冲突错误。

我已经在上面讨论了这个问题，让我在这里再说一遍。如果我们在导入另一个包时在包内创建一个类，那么包声明应该是第一个语句，然后是包导入。例如：

```java
package abcpackage;
import xyzpackage.*;
```

3.  一个类只能有一个包声明，但它可以有多个包导入语句。例如：

```java
package abcpackage; //This should be one
import xyzpackage;
import anotherpackage;
import anything;
```

4.  使用子包时，应谨慎使用`*`等通配符导入。例如：让我们说：我们有一个包`abc`，在那个包中我们有另一个包`foo`，现在`foo`是一个子包。

`abc`中的类是：`Example1`，`Example2`和`Example3`
`foo`中的类是：`Demo1`，`Demo2`

所以，如果我使用这样的通配符导入包`abc`：

```java
import abc.*;
```

然后它只会导入类`Example1`，`Example2`和`Example3`，但它不会导入子包的类。

要导入子包的类，您需要像这样导入：

```java
import abc.foo.*;
```

这将导入`Demo1`和`Demo2`，但不会导入`Example1`，`Example2`和`Example3`。

因此要导入包和子包中的所有类，我们需要使用两个`import`语句，如下所示：

```java
import abc.*;
import abc.foo.*;
```