您当前的位置： 首页 > 学无止境 > 心得笔记 网站首页心得笔记
【第8章：包及访问控制权限】_包的定义及导入
发布时间：2020-12-19 13:53:55编辑：雪饮阅读（）
定义一个包
package org.gaojiupan.a;
class Demo{
public String getInfo(){
return "hello world";
}
}
public class TestJava{
public static void main(String args[]){
System.out.println(new Demo().getInfo());
}
}
打包编译
这里定义了一个包路径为org\gaojiupan\a，然后这个包中有TestJava
那么编译的时候就不能直接javac TestJava.java的方式进行编译了，而是采用打包编译，如：
D:\>javac -d . TestJava.java
这里的“.”是必须的，指代当前目录
包的使用
既然定义为一个包，则该包的使用也不会像之前单文件的类那样使用了，而是如：
D:\>java org.gaojiupan.a.TestJava
hello world
包的导入
先定义一个b的包，由于一个包中的类要想被其它包能够访问所以该类必须是public权限修饰的，而一个.java文件中有且仅有一个类可以被修饰为public并且被修饰为public的类的名称必须和.java这个文件的文件名名称相同，所以这个java文件也就假定为B1.java
package org.gaojiupan.b;
public class B1{
public String getInfo(){
return "hello world";
}
}
然后所谓的包的导入就是指在一个java文件中导入另外一个非当前java文件所在包的其它包的类。所以另外建立一个java文件然后导入b包中的B1这个类如：
package org.gaojiupan.a;
import org.gaojiupan.b.B1;
class Demo{
public String getInfo(){
return "hello world";
}
}
public class TestJava{
public static void main(String args[]){
System.out.println(new B1().getInfo());
}
}
包导入之后那么我们入口的这个TestJava.java则就相当于依赖于b包了，毕竟主方法中还new了b包中的类，所以TestJava.java再进行编译的时候也就需要先编译其依赖的包，然后再编译当前这个TestJava.java。如：
D:\>javac -d . B1.java
D:\>javac -d . TestJava.java
然后执行TestJava.java
D:\>java org.gaojiupan.a.TestJava
hello world
包中类的批量导入
比如有B1.java与B2.java都属于B包，那么要想批量导入B包中的所有类，就是说可能不止B1.java和B2.java有可能还有B3.java、B4.java…都属于B包。可不要理解错了。
那么B1.java如：
package org.gaojiupan.b;
public class B1{
public String getInfo(){
return "hello world";
}
}
那么B2.java如：
package org.gaojiupan.b;
public class B2{
public String getInfo(){
return "b包中的B2类";
}
}
那么导入B包中所有类的这个TestJava.java如
package org.gaojiupan.a;
import org.gaojiupan.b.*;
class Demo{
public String getInfo(){
return "hello world";
}
}
public class TestJava{
public static void main(String args[]){
System.out.println(new B2().getInfo());
}
}
那么编译的时候当然也就要把B包中所有类所在的.java文件都要编译了
D:\>javac -d . B1.java
D:\>javac -d . B2.java
然后才能编译TestJava.java
D:\>javac -d . TestJava.java
然后才能执行
D:\>java org.gaojiupan.a.TestJava
b包中的B2类
批量导入包中类带来的冲突
假定对于原来B1.java修改如现在这样：
package org.gaojiupan.c;
public class B1{
public String getInfo(){
return "hello world";
}
}
然后重新编译B1.java由于原来是在b包中的，现在在c包中了
那么重新编译后c包中有B1类了，b包中也有B1类了
那么此时正好TestJava.java中又同时批量导入了b包与c包中的所有类，那么此时TestJava.java中就重复出现了B1类。
package org.gaojiupan.a;
import org.gaojiupan.b.*;
import org.gaojiupan.c.*;
public class TestJava{
public static void main(String args[]){
System.out.println(new B1().getInfo());
}
}
D:\>javac -d . B1.java
D:\>javac -d . TestJava.java
D:\>javac -d . TestJava.java
TestJava.java:6: 对 B1 的引用不明确，org.gaojiupan.c 中的 类 org.gaojiupan.c.B1 和 org.gaojiupan.b 中的 类 org.gaojiupan.b.B1 都匹配
System.out.println(new B1().getInfo());
^
1 错误
所以此时要想TestJava.java能够编译通过，则需要在TestJava.java中明确指定要用那个包中的B1类来new
package org.gaojiupan.a;
import org.gaojiupan.b.*;
import org.gaojiupan.c.*;
public class TestJava{
public static void main(String args[]){
System.out.println(new org.gaojiupan.c.B1().getInfo());
}
}
D:\>javac -d . TestJava.java
D:\>java org.gaojiupan.a.TestJava
hello world
静态导入
当一个包中一个类中的方法全部是静态的时候可以采用静态导入该包中这个类的所有方法
假定又Operate.java如：
package org.gaojiupan.d;
public class Operate{
public static int add(int i,int j){
return i+j;
}
public static int mul(int i,int j){
return i*j;
}
}
则在TestJava.java中进行静态导入则如：
package org.gaojiupan.a;
import static org.gaojiupan.d.Operate.*;
public class TestJava{
public static void main(String args[]){
System.out.println(add(1,1));
System.out.println(mul(1,3));
}
}
D:\>javac -d . Operate.java
D:\>javac -d . TestJava.java
D:\>java org.gaojiupan.a.TestJava
2
3
jar打包
先了解下jar命令
D:\>jar ?
非法选项：?
用法: jar {ctxui}[vfm0Me] [jar-file] [manifest-file] [entry-point] [-C dir] files ...
选项包括：
-c 创建新的归档文件
-t 列出归档目录
-x 解压缩已归档的指定（或所有）文件
-u 更新现有的归档文件
-v 在标准输出中生成详细输出
-f 指定归档文件名
-m 包含指定清单文件中的清单信息
-e 为捆绑到可执行 jar 文件的独立应用程序
指定应用程序入口点
-0 仅存储；不使用任何 ZIP 压缩
-M 不创建条目的清单文件
-i 为指定的 jar 文件生成索引信息
-C 更改为指定的目录并包含其中的文件
如果有任何目录文件，则对其进行递归处理。
清单文件名、归档文件名和入口点名的指定顺序
与 "m"、"f" 和 "e" 标志的指定顺序相同。
示例 1：将两个类文件归档到一个名为 classes.jar 的归档文件中：
jar cvf classes.jar Foo.class Bar.class
示例 2：使用现有的清单文件 "mymanifest" 并
将 foo/ 目录中的所有文件归档到 "classes.jar" 中：
jar cvfm classes.jar mymanifest -C foo/ .
因为我们java开发好之后给部署的时候是部署的java编译之后的class文件，而这些文件是非常多的，不可能一个个的去折腾，比较麻烦，所以jar提供打包功能。
我们不妨先看看上面练习之后产生的这些包所编译的之后所产生的文件结构，因为编译之后包名最顶级就是org，我们直接tree下org即可。
D:\>tree org
文件夹 PATH 列表
卷序列号为 CEDA-A76E
D:\ORG
└─gaojiupan
├─a
├─b
├─c
└─d
可见这只是几个小练习就有这些目录了，那么如果是一个完整的项目，则会更加复杂，所以jar打包的作用也就是在这里所体现出来的。
了解了jar之后及相关命令的相关参数之后所以我们打包我们这里的org目录则如：
D:\>jar -cvf my.jar org
标明清单(manifest)
增加：org/(读入= 0) (写出= 0)(存储了 0%)
增加：org/gaojiupan/(读入= 0) (写出= 0)(存储了 0%)
增加：org/gaojiupan/a/(读入= 0) (写出= 0)(存储了 0%)
增加：org/gaojiupan/a/B2.class(读入= 301) (写出= 232)(压缩了 22%)
增加：org/gaojiupan/a/Demo.class(读入= 293) (写出= 228)(压缩了 22%)
增加：org/gaojiupan/a/TestJava.class(读入= 490) (写出= 342)(压缩了 30%)
增加：org/gaojiupan/b/(读入= 0) (写出= 0)(存储了 0%)
增加：org/gaojiupan/b/B1.class(读入= 285) (写出= 225)(压缩了 21%)
增加：org/gaojiupan/b/B2.class(读入= 289) (写出= 224)(压缩了 22%)
增加：org/gaojiupan/b/Bdemo.class(读入= 287) (写出= 226)(压缩了 21%)
增加：org/gaojiupan/b/C.class(读入= 283) (写出= 222)(压缩了 21%)
增加：org/gaojiupan/c/(读入= 0) (写出= 0)(存储了 0%)
增加：org/gaojiupan/c/B1.class(读入= 285) (写出= 224)(压缩了 21%)
增加：org/gaojiupan/d/(读入= 0) (写出= 0)(存储了 0%)
增加：org/gaojiupan/d/Operate.class(读入= 308) (写出= 221)(压缩了 28%)
jar包的使用
那么上面jar打包之后就整个扔给客户端，我们这里可以把刚才那个org目录整个删除了，
然后设置下classpath将jar路径设置进去，然后最好把当前路径也设置进去，多个路径用分号来分隔。
则假定我是客户端，对于上面的jar包我直接使用如：
D:\>set classpath=.;d:\my.jar
D:\>java org.gaojiupan.a.TestJava
2
3
查看jar包详情
有时候可能会想要知道这个jar包中都有些什么类，则需要查看该jar包中的详情。
根据上面jar的一些参数则我们查看jar包的详情如
关键字词：java,包,访问控制权限,包的定义及导入