包的定义与使用 
 
在开发过程中，会定义很多类，为了避免相同类名称出现而发生覆盖的情况，把所有java程序保存在各自的目录里面，而该目录就是包。包的本质实际上就是一个文件夹。
 
 一、包的定义
 
java程序是由一个public类和众多非public的类组成，在java程序的第一行加入“package 包名称；”，就可以把*.class文件保存在相应的包内；当需要调用此包中的类时，用“包名称.类名称”的格式调用，这样可以避免相同类名的冲突。
 注：在命名包名称时，尽量避开与系统冲突的名字，例如java.lang等；同时包名一般都采用小写形式。
一旦程序类中出现了包名称之后，在执行程序使用类名称时，应尽量带上包名称，而不是进入包内执行。
 注：在以后进行项目开发中，所有.java文件一定要使用package定义包。
 
 二、包的导入
 
因为包之间会存在相互调用的情况，一个包不但会调用本包中类，还会调用其他包中的类，所以需要用关键词“import”进行导入包中的类，格式：import 包名称.类名称；
当需要导入其他包中的若干类，如果一个一个的写比较麻烦，可以用格式：import 包名称.*；来完成导入。
 注：使用通配符 “ * ” 并不意味着将包内的类全部导入，而是按照需求导入，需要什么类就导入什么类。
如果在不同的包中包含有相同名称的类名，可以采用“包名称.类名称”加以区分。
 例如：
 
cn.aaa.www.Demo  demo=new  cn.bbb.www.Demo();
 
注：该句代码表示产生cn.bbb.www包内中Demo类的一个实例化对象，赋给cn.aaa.www包中的Demo类，对象引用为demo。
 
代码示例：
 
package cn.aaa.www;
public class Hello{
	public void print() {
		System.out.println("cn.aaa.www包内的Hello类！");
	}
}

package cn.bbb;
import cn.aaa.www.Hello;//导入程序类
public class World{
	public static void main(String[] args) {
		Hello hello=new Hello();
		hello.print();
	}
}
 
运行结果
 
cn.aaa.www包内的Hello类！
 
 三、系统常用包
 
java.lang ：系统的常用基础类，例如String，Object类等。
java.lang.reflect
java.math
java.util
java.io ：io编程的开发包。
java.applet
java.awt.javax.swing等等，可以查看文档。
 
注意：
 
包也限定了访问权限，只有具有访问权限的类才能访问某个包中的类。
 
No
范围
private
default
protected
public
1
同一个包中的同一个类
√
√
√
√
2
同一包中的不同类
-
√
√
√
3
在不同包中的子类
-
-
√
√
4
在不同包中的非子类
-
-
-
√
<基于访问权限问题，在开发过程中，一般属性都用private封装，方法的权限用public>
 
 四、jar命令（开发中会大量使用）
 
jar相当于一种压缩文件，里面保存的是“*.class”文件。即生成了一个用package关键字打包的内容的压缩文件。
 
下图是jar命令中的参数及其含义：
 
 使用jar命令的作用：
 
在一个java程序中会存在很多“*.class”文件，将其压缩可以节省空间；
压缩生成jar文件之后，在调用jar文件中文件夹中的类时，不能像标题“二、包的导入”那样直接导入了，需要配置CLASSPATH，设置jar的加载路径；
在实际的开发中，因为会用到第三方程序包，所以会用到jar文件，所以开发包必须在CLASSPATH中配置后才能使用。
 
<具体的配置与java开发环境配置CLASSPATH方法相同，不在这赘述。>

包的定义与使用
 
1、包的定义：
 
.java文件中使用package 定义java文件的包。包实际上就是一个目录，为了防范由于类名相同而引起的错误，同一个包中，不允许使用相同类名。
 
java -d ：将打包文件
 
2、包的导入
 
java通过 import 关键字导入java类，
 
导入单个一个类： import 包名.类名
 
使用通配符导入： import 包名.*
 
当不同的包使用相同的类名称，且同一个java文件导入不同包下的相同类名称会出现，类引用不明确错误，此时需要在程序中，明确实例化具体类。
 
包名.类名 引用变量 = new 包名.类名();
 
3、访问控制权限
 
private
 
default
 
protected
 
public
 
4、jar命令的使用
 
jar -‘cvf’ 类名称 ：打包类成为一个.jar文件
 
但是需要将jar包的路径设置在classpath的环境变量中，你才可以使用自己的jar包
 
 
 
 
 
 
 

一、包的定义
 
包指的是一个程序的目录，在最早的时候如果要开发一个程序，只需要定义一个*.java文件，而后在这个文件里面编写所需要的类文件，而在编译之后程序将直接保存在根目录下，而利用包可以实现同一个程序的拆分，即：可以根据要求将代码保存在不同的目录下。
 
如果要定义包可以使用关键字package关键字完成。
 
 
 
范例：定义包
 
 
package cn.zhai.demo;

public class Hello {
	public static void main(String args[]) {
		System.out.println("Hello World!!");
	}
}
 
 
如果在定义包的时候出现了“.”，那么就表示子目录。如果说类有包的定义了，那么就必须让其保存在特定的目录下，只不过不要自己去手工创建这些目录，应该使用命令自动生成：
 
 
 
· 打包编译：java-d.Hello.java;
 
 
     |-“-d”：生成目录，根据package的定义生成；
 
 
     |-“.”：设置保存的路径，如果为“.”表示在当前所在路径下生成；
 
 
· 在解释程序的时候不要进入到包里面解释程序，应该在包外面输入类的完整名称（包.类）；
 
 
     |-输入：java cn.zhai.demo.Hello
 
 
以后所有的类都一定要定义在包之中，那么完整的类名称就是“包.类”。
 

二、包的导入
 
使用包可以将一个完整的程序拆分为不同的文件进行分别保存，这样就会造成一个问题，不同包之间有可能互相访问，那么此时就需要使用导包的操作，使用import语句完成即可。
 
 
 
范例：定义一个cn.zhai.util.Message的类
 
 
package cn.zhai.util;

class Message {
	public void print() {
		System.out.println("Hello World!!!");
	}
}
 
 
 
 
范例：定义一个cn.zhai.test.TestMessage的类
 
 
这个类要使用Message类
 
 
package cn.zhai.test;

import cn.zhai.util.Message;//导入要使用的类

public class TestMessage {
	public static void main(String[] args) {
		Message msg = new Message();
		msg.print();
	}
}
 
 
对于程序的编译应该采用先编译Message，而后再编译TestMessage的顺序完成。
 
 
 
总结：关于public class和class声明类的完整区别？
 
 
· public class：文件名称必须与类名称保持一致，在一个*.java文件里面只能够有一个public class声明，如果一个类需要被不同的包所访问那么一定要定义为public class；
 
 
· class：文件名称可以与类名称不一致，并且一个*.java文件里面可以有多个class定义，编译后会形成多个*.class文件，如果一个类使用的是class定义，那么表示这个类只能够被本包所访问。
 
 
 
 
 
 
范例：修改Message.java类的定义
 
 
package cn.zhai.util;

public class Message {
	public void print() {
		System.out.println("Hello World!!!");
	}
}
 
 
Java编译器考虑到了作为大型程序开发的时候有可能会存在有多个*.java互相引用的情况，为了解决这个问题，所以提供了通配符“*”操作：java-d.*.java。
 
但是发现在导入包的时候也出现了一个问题，如果使用一个包中类的时候要编写“import 包.类”，那么如果说要使用一个包中多个类的时候，那么肯定要重复去编写“import 包.类”，这样是很麻烦的，所以此时可以使用“包.*”的方式来代替一个包中多个类的导入操作。
 
package cn.zhai.test;

import cn.zhai.util.*;//导入要使用的类

public class TestMessage {
	public static void main(String[] args) {
		Message msg = new Message();
		msg.print();
	}
}
 
使用“包.*”指的并不是全部导入，而是只导入程序里面所需要的类，所以不需要去考虑性能问题。
 
但是既然出现了导包操作，那么就必须有一个重要的问题需要注意，有可能同一个代码里面会同时导入不同的包，并且这不同的包里面有可能会存在同名类，例如：现在有两个类：
 
· cn.zhai.util.Message;
 
· org.zyx.Message;
 
由于某种需要，要同时导入以上两个包。
 
package org.zyx;

public class Message {
	public void get() {
		System.out.println("世界，你好!!!");
	}
}
 
对于TestMessage类，由于某种需求，同时需要导入两个包。
 
package cn.zhai.test;

//这两个包里面都有同一个类名称(Message)
import cn.zhai.util.*;//导入要使用的类
import org.zyx.*;

public class TestMessage {
	public static void main(String[] args) {
		Message msg = new Message();
		msg.print();
	}
}


Exception in thread "main" java.lang.Error: 无法解析的编译问题：
	类型 Message 有歧义
	类型 Message 有歧义
 
那么在这种情况下为了可以明确的找到所需要的类，那么可以在使用类的时候加上包名称。
 
 
 
		cn.zhai.util.Message msg = new cn.zhai.util.Message();
 
 
如果觉得导包操作会造成冲突，那么就在实例化对象的时候写上完整的类名称。
 

三、系统常见包
 
Java本身提供了大量的程序开发包（除了Java自己提供的，还有许多第三方提供了开发包）。在Java开发里面，有如下的一些常见的系统包。
 
· java.lang：包含了String、Object、Integer等类，从JDK 1.1开始此包自动导入；
 
· java.lang.reflect：反射开发包；
 
· java.util：Java的工具包，提供了大量的工具类，像链表；
 
· java.util.regex：正则工具包；
 
· java.text：国际化处理程序包；
 
· java.io：进行输入、输出处理以及文件操作；
 
· java.net：网络编程开发包；
 
· java.sql：数据库程序开发包；
 
· java.applet：Applet程序开发包（已经不用了）；
 
      |-Applet指的是在网页上嵌套的程序，采用绘图的方式完成的显示。而Application 是在主方法中运行，通过命令行执行。随着时间的发展，Applet程序已经不再使用（使用Canvas绘图--HTML5）。
 
· java.awt、javax.swing：图形界面的开发包，主要功能是进行单机版程序界面编写的；
 
      |-JDK1.0的时候主要推出的是awt开发包，但是这个开发包使用了大量的windows图形函数；
 
      |-JDK 1.2的时候推出了javax.swing开发包，是一个轻量级（Java自己写的，不再使用windows），Java从此更名为Java 2；
 

四、jar命令
 
在任何一个项目里面一定会存在有大量的*.class文件，那么如果将这些*.class文件直接交给用户使用，那么会造成文件过多，并且会导致程序非常没有结构，所以在交付用户使用之前，会使用jar命令针对于*.class文件进行压缩，并且压缩的单位都是以包为主的。
 
 
 
 
 
 
 
范例：定义一个Message.java文件
 
 
package cn.zhai.util;

public class Message {
	public void print() {
		System.out.println("Hello World!!!");
	}
}
 
 
随后打包编译此文件：javac -d.Message.java
 
此时会形成“包.类”的形式。随后假设这里面有很多的*.class文件，并且要交付用户使用，那么将这个包的代码压缩，输入：jar -cvf my.jar cn
 
生成的my.jar文件并不能够直接使用，必须配置CLASSPATH才可以加载。
 
 
 
SET CLASSPATH=.；E:\mydemo\my.jar
 
 
在以后的开发之中需要大量的使用第三方的jar文件，那么所有的jar文件必须配置CLASSPATH，否则不能够使用。
 
最简单的配置方式可以直接在环境属性中完成。
 
 

1、 包的定义
 
/**
 * 自定义Spark.navigation包
 */
package spark.navigation{
  abstract class Navigator{
    def act
  }
  package tests{
    //在spark.navigation.tests包里定义一个类
    class NavigatorSuite
  }
  package impls{
    class Action extends Navigator{
      def act=println("Action-易悠")
    }
  }
}

/**
 * 自定义Hadoop包
 */
package hadoop{
  package navigation {
    class Navigator
  }
  package launch{
  //import kmust.hjr.learningScala16.hadoop.navigation.Navigator
    class Booster{
      val nav =new navigation.Navigator
      //val nav=new Navigator
    }
  }
}
 
2、 包对象
 
/**
 *包对象的定义
 */
package object people{
    var defaultName="KMUST-易悠"
}
/**
  *包对象的使用
 */
package people{
  class people{
    var name=defaultName
  }
}
 
3、 包的引用
 
import java.awt.{Color,Font}
import java.util.{HashMap=>JavaHashMap}//别名
import scala.{StringBuilder=>_}//占位符_和*
 
附录：