Java教程32—Java中的包及使用案例

短命女 2022-05-12 07:52 44阅读 0赞

*   *  在Java中使用包的优点
     *  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文件

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));
        }
    }

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

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那么您可以像这样导入包，以使用此包的所有类。

import letmecalculate.*;

--------------------

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

//声明一个包
    package anotherpackage;
    //导入一个包
    import letmecalculate.Calculator;
    public class Example{
        public static void main(String args[]){
            Calculator obj = new Calculator();
            System.out.println(obj.add(100, 200));
        }
    }

所以例子中的顺序因该是

→ package declaration(包声明)
    → package import(包导入)

--------------------

**示例3：导入类时使用全局限定名称**  
您可以使用全局限定名称来避免import语句。  
让我们看一个例子来理解这个：

Calculator.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

//声明一个包
    package anotherpackage;
    public class Example{
        public static void main(String args[]){
            //用全局限定名代替import
            letmecalculate.Calculator obj =
                    new letmecalculate.Calculator();
            System.out.println(obj.add(100, 200));
        }
    }

在Example类中，我使用了完整的限定名称package\_name.class\_name以创建它的对象，而不是导入包。

--------------------

## Java中的子包 ##

另一个包中的包称为子包。  
例如，如果我在letmecalculate包中创建一个包，那么它将被称为子包。  
可以说我在包letmecalculate里面创建了另一个子包，子包名是multiply。  
因此，如果我在这个子包中创建一个类，它应该在开头有这个包声明：

package letmecalculate.multiply;

Multiplication.java

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

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

import letmecalculate.multiply;

或者用全局限定引用:

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

--------------------

## 关键的几点 ##

**1.有时可能会发生类名冲突。**  
例如：假设我们有两个包abcpackage和xyzpackage，并且这两个包都有一个具有相同名称的类。  
比方说这个JavaExample类。现在假设JavaExample类导入这两个包，如下所示：

import abcpackage.*;
    import xyzpackage.*;

这将抛出编译错误，为了避免这种错误，你需要使用我上面说的全局限定方法，如：

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

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

--------------------

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

package abcpackage;
    import xyzpackage.*;

--------------------

**3、 一个类仅仅可以有一个包声明，但是它可以有多个包导入。例如：**

package abcpackage; //仅此一个
    import xyzpackage;
    import anotherpackage;
    import anything;

--------------------

**4、使用子包时，`package.*`这种通配符导入时需要特别小心。**  
例如：让我们说：我们有一个包abc，在包abc中我们有另一个包foo，现在foo是一个子包。  
abc中的类是：Example1, Example 2, Example 3  
foo中的类是：Demo1, Demo2  
所以如果我使用这样的通配符导入包abc：

import abc.*;

然后它只会导入类Example1，Example2和Example3，但它不会导入子包的类。  
要导入子包类，您需要像这样导入：

import abc.foo.*;

这将导入Demo1和Demo2，但不会导入Example1，Example2和Example3。  
因此要导入package和subpackage中的所有类，我们需要使用两个import语句，如下所示：

import abc.*;
    import abc.foo.*;

--------------------

原文地址：

https://beginnersbook.com/2013/03/packages-in-java/