Java包-yiteyi-C++库

包裹在里面 JAVA 是一种封装一组类、子包和接口的机制。软件包用于：

null

防止命名冲突。例如，在两个包中可以有两个名为Employee的类，即college。工作人员cse。员工和大学。工作人员嗯。受雇者
使类、接口、枚举和注释的搜索/定位和使用更容易
提供受控访问：受保护和默认具有包级访问控制。受保护的成员可由同一包及其子类中的类访问。默认成员（没有任何访问说明符）只能由同一包中的类访问。
包可以被视为数据封装（或数据隐藏）。

我们所需要做的就是将相关类放入包中。之后，我们可以简单地从现有的包中编写一个导入类，并在我们的程序中使用它。包是一组相关类的容器，其中一些可访问的类是公开的，而另一些则是为了内部目的而保留的。我们可以在程序中根据需要多次重用包中的现有类。

软件包是如何工作的？

包名和目录结构密切相关。例如，如果包名为 学院工作人员cse ，然后有三个目录，学院 , 工作人员 和 cse 以至于 cse 存在于 工作人员 和 工作人员 存在学院 .还有目录学院可以通过类路径变量，即CLASSPATH中存在学院的父目录路径。这样做的目的是确保类易于定位。 包命名约定： 软件包的命名顺序与域名相反，即org。极客。实践例如，在大学里，推荐的惯例是大学。科技cse，大学。技术工程师，大学。艺术历史等等。

将类添加到包中： 通过在程序顶部使用包名并将其保存在包目录中，我们可以向创建的包添加更多类。我们需要一个新的 JAVA 文件来定义公共类，否则我们可以将新类添加到现有类中 JAVA 归档并重新编译。

子包： 在另一个包中的包是分装。默认情况下不会导入这些内容，它们必须显式导入。此外，子包的成员没有访问权限，也就是说，它们被视为受保护和默认访问说明符的不同包。 例子：

import java.util.*;

util 是否在内部创建了子包 JAVA 包裹

访问包中的类

考虑以下两个陈述：

// import the Vector class from util package.
import java.util.vector; 

// import all the classes from util package
import java.util.*;

第一条语句用于导入矢量来自 util 里面装的包裹 JAVA .
第二条语句从中导入所有类 util 包裹

// All the classes and interfaces of this package
// will be accessible but not subpackages.
import package.*;

// Only mentioned class of this package will be accessible.
import package.classname;

// Class name is generally used when two packages have the same
// class name. For example in below code both packages have
// date class so using a fully qualified name to avoid conflict
import java.util.Date;
import my.package.Date;

                     // Java program to demonstrate accessing of members when                   
                     // corresponding classes are imported and not imported.                   
                     import                               java.util.Vector;                   
                             
                     public                               class                               ImportDemo                   
                     {                   
                                         public                               ImportDemo()                   
                                         {                   
                                         // java.util.Vector is imported, hence we are                   
                                         // able to access directly in our code.                   
                                         Vector newVector =                               new                               Vector();                   
                             
                                         // java.util.ArrayList is not imported, hence                   
                                         // we were referring to it using the complete                   
                                         // package.                   
                                         java.util.ArrayList newList =                               new                               java.util.ArrayList();                   
                                         }                   
                             
                                         public                               static                               void                               main(String arg[])                   
                                         {                   
                                         new                               ImportDemo();                   
                                         }                   
                     }                   

包裹类型： packages

内置软件包 这些包由大量类组成，这些类是Java的一部分 美国石油学会 。一些常用的内置软件包包括： 1) JAVA朗： 包含语言支持类（例如定义基本数据类型、数学运算的classed）。这个包是自动导入的。 2) JAVAio: 包含用于支持输入/输出操作的分类。 3) JAVAutil: 包含实现数据结构的实用程序类，如链表、字典和支持；用于日期/时间操作。 4) JAVA小程序： 包含用于创建小程序的类。 5) JAVAawt： 包含用于实现图形用户界面组件的类（如按钮、菜单等）。 6) JAVA净： 包含支持网络操作的类。

用户定义的包 这些是由用户定义的包。首先我们创建一个目录 我的包裹 （名称应与包的名称相同）。然后创建类名在目录中，第一条语句是包名 .

// Name of the package must be same as the directory
// under which this file is saved
package myPackage;

public class MyClass
{
    public void getNames(String s)
    {        
        System.out.println(s);        
    }
}

现在我们可以使用类名在我们的课程中。

/* import 'MyClass' class from 'names' myPackage */
import myPackage.MyClass;

public class PrintName 
{
   public static void main(String args[]) 
   {       
      // Initializing the String variable 
      // with a value 
      String name = "GeeksforGeeks";
      
      // Creating an instance of class MyClass in 
      // the package.
      MyClass obj = new MyClass();
      
      obj.getNames(name);
   }
}

注： 我的班级。JAVA 必须保存在 我的包裹 目录，因为它是包的一部分。

使用静态导入

静态导入是中引入的一项功能 JAVA 允许类中定义为公共的成员（字段和方法）的编程语言（版本5及以上） 静止的 在Java代码中使用，而不指定定义字段的类。下面的程序演示 静态导入 :

                     // Note static keyword after import.                   
                     import                               static                               java.lang.System.*;                   
                             
                     class                               StaticImportDemo                   
                     {                   
                                         public                               static                               void                               main(String args[])                   
                                         {                   
                                         // We don't need to use 'System.out'                   
                                         // as imported using static.                   
                                         out.println(                               "GeeksforGeeks"                               );                   
                                         }                   
                     }                   

输出：

 GeeksforGeeks

处理名称冲突

我们唯一需要注意的是当我们有名字冲突的时候。例如，两者都是java。util和java。sql包有一个名为Date的类。所以，如果我们在程序中导入两个包，如下所示：

import java.util.*;
import java.sql.*;

//And then use Date class, then we will get a compile-time error :

Date today ; //ERROR-- java.util.Date or java.sql.Date?

编译器将无法确定我们想要哪个日期类。这个问题可以通过使用特定的导入语句来解决：

import java.util.Date;
import java.sql.*;

如果我们需要两个日期类，那么每次声明该类的新对象时都需要使用完整的包名。例如：

java.util.Date deadLine = new java.util.Date();
java.sql.Date today = new java.sql.Date();

目录结构

包名与用于存储类的目录结构密切相关。属于特定包的类（和其他实体）一起存储在同一目录中。此外，它们存储在由包名指定的子目录结构中。例如，包com的类循环。zzz。项目1。子项目2存储为“$BASE_DIRcomzzzproject1subproject2Circle.class”，其中$BASE_DIR表示包的基本目录。显然，包名中的“点”对应于文件系统的子目录。

基本目录（$base_DIR）可以位于文件系统中的任何位置。因此，必须通知Java编译器和运行时$BASE_DIR的位置，以便定位类。这是由一个名为CLASSPATH的环境变量完成的。CLASSPATH类似于另一个环境变量PATH，命令shell使用该变量搜索可执行程序。

设置类路径 : 类路径可以通过以下任意方式设置：

类路径可以在环境中永久设置：在Windows中，选择控制面板？系统先进的环境变量？选择“系统变量”（适用于所有用户）或“用户变量”（仅适用于当前登录的用户）？选择“编辑”（如果类路径已经存在）或“新建”？输入“CLASSPATH”作为变量名？输入所需的目录和JAR文件（用分号分隔）作为值（例如“；c:javaprojectclasses；d:omcatlibservlet api.JAR”）。请注意，您需要在类路径中包含当前工作目录（用“.”表示）。要检查类路径的当前设置，请发出以下命令：
```
> SET CLASSPATH
```
通过发出以下命令，可以为特定的CMD shell会话临时设置类路径：
```
> SET CLASSPATH=.;c:javaprojectclasses;d:	omcatlibservlet-api.jar
```

除了使用CLASSPATH环境变量之外，您还可以使用javac和java命令的命令行选项-CLASSPATH或-cp，例如，

> java –classpath c:javaprojectclasses com.abc.project1.subproject2.MyClass3

用户定义包的图示： 创建我们的第一个包：文件名–ClassOne。JAVA

                         package                                     package_name;                       
                                   
                         public                                     class                                     ClassOne {                       
                                                 public                                     void                                     methodClassOne() {                       
                                                 System.out.println(                                     "Hello there its ClassOne"                                     );                       
                                                 }                       
                         }                       

创建我们的第二个包：文件名–class2。JAVA

                         package                                     package_one;                       
                                   
                         public                                     class                                     ClassTwo {                       
                                                 public                                     void                                     methodClassTwo(){                       
                                                 System.out.println(                                     "Hello there i am ClassTwo"                                     );                       
                                                 }                       
                         }                       

使用创建的两个包：文件名–测试。JAVA

                         import                                     package_one.ClassTwo;                       
                         import                                     package_name.ClassOne;                       
                                   
                         public                                     class                                     Testing {                       
                                                 public                                     static                                     void                                     main(String[] args){                       
                                                 ClassTwo a =                                     new                                     ClassTwo();                       
                                                 ClassOne b =                                     new                                     ClassOne();                       
                                                 a.methodClassTwo();                       
                                                 b.methodClassOne();                       
                                                 }                       
                         }                       

输出：

Hello there i am ClassTwo
Hello there its ClassOne

现在来看一下包和测试类文件的目录结构：

要点：

每门课都是某个包的一部分。
如果未指定包，则文件中的类将进入一个特殊的未命名包（所有文件都是同一个未命名包）。
文件中的所有类/接口都是同一个包的一部分。多个文件可以指定相同的包名。
如果指定了包名，则文件必须位于名为name的子目录中（即，目录名必须与包名匹配）。
我们可以通过以下方式访问另一个（命名）包中的公共类： 包裹名称。类名

相关文章： Java软件包测试 参考： http://pages.cs.wisc.edu/~hastin/cs368/JavaTutorial/NOTES/Packages。html 本文由 尼希尔·梅赫瓦尔 还有普拉蒂克·阿加瓦尔。如果你喜欢Geeksforgek，并且想贡献自己的力量，你也可以使用写极客。组织或者把你的文章寄去评论-team@geeksforgeeks.org.看到你的文章出现在Geeksforgeks主页上，并帮助其他极客。

如果您发现任何不正确的地方，或者您想分享有关上述主题的更多信息，请写下评论。

文章版权归作者所有，未经允许请勿转载。

THE END

Java