java基础_7_包

package

概述
包，类似于文件夹，组织管理类的结构。
书写：www.sina.com 倒过来 com.sina.www
建立包在编译时：完整类名：包名+.+类名。
路径：com \it18zhang\java\PackageDemo.class
完整类名：com .it18zhang.java.PackageDemo
编译含有包名的类：
javac -d classes xxx.java //-d指定存放classes文件的位置
//同时生成对应的文件夹目录树
javac -cp classes -d .xxx.java//-cp指定编译程序时需要搜索的类路径顺序
演示
PackageDemo

package com.it18zhang.java;//包名
class PackageDemo
{
 public static void main(String []args)
 {
  System.out.println("hello world1");
 }
 

编译包
1:
尝试一下吧：javac PackageDemo.java
结果：
编译成功，但是有没有我们要的com，文件夹？显然没有
2
运行一下类把：java PcakageDemo
结果：
为什么？因为这个类带包了，一带包这个类的完整类名时什么？
类名=包名+.+类名
3
查看一下完整类名：javap PackageDemo
结果：
4
尝试：java com.it18zhang.java.PackageDemo
结果：
如果类在包里，包要转变成文件夹，到对应的文件夹下搜索类
虽然编译了，但是编译的时候没产生文件夹，javac编译要产生对应的文件夹
javac -d classes xxx.java //-d指定存放classes文件的位置
//同时生成对应的文件夹目录树
5
尝试：javac -d.PackageDemo.java
结果：
有没有产生com？
6
进入com，使用tree树状图

7
操作：cd it18hzang\java+dir

8
在当前目录下运行

崩溃了？怎么又不可以？我需要出来才可以
9
操作：cd..+cd..+cd..+java com.it18zhang.java.PackageDemo
结果：

这样就ok了
10
删掉comrmdir /s com一般运行时不会放在当前文件夹，我们一般放在一个新的文件夹，假设叫classes
操作：javac -d classes PackageDemo.java
看一下tree的操作：tree/？
然后：tree /F
结果:
A与AA的不要管；这样就创立在classes文件下了；然后运行java，需要在与com同目录下运行java才可以。

在同一个包下创建两个类

1：

package com.fanyongjun.java;
class PackageDemo1
{
 public static void main(String []args)
 {
  System.out.println("hello world1");
 }
 public static void sayHello(String msg){
  System.out.println(msg);
 }
}
class PackageDemo2
{
 public static void main(String []args)
 {
  System.out.println("hello world2");
 }
 
}

2
编译：javac -d classes PackageDemo.java
结果：
3
运行1：java com.fanyongjun.java.PackageDemo1
运行2：java com.fanyongjun.java.PackageDemo2
结果：

在不同的包下创建类

PackageDemo1

package com.fanyongjun.java1;
class PackageDemo1
{
 public static void main(String []args)
 {
  System.out.println("hello world");
 }
 public static void sayHello(String msg){
  System.out.println(msg);
 }
}

PackageDemo2

package com.fanyongjun.java2;
//访问Demo导入指定的类
import com.fanyongjun.java1.PackageDemo1;
public class PackageDemo2
{
 public static void main(String []args)
 {
  PackageDemo1.SayHello("helljava1");
  System.out.println("hello world2");
 }
}
//都加public 才能访问

1
编译：javac -d classes PackageDemo1.java PackageDemo2.java
查看结果：
2
运行：java -cp .. com.fanyongjun.java1.PackageDemo1

在上述我们添加了引用，调用包2的时候能调用包1的内容用import
看代码就可以了，注意调用其他包的
内容是必须都是public的才可以，后面我们会单独讲到权限问题

引入包中的类，需要使用import关键字
import com.it18zhang.java1.PackageDemo1;
public class xxx{
.....
}

dos 命令
1：tree /F   //输出目录树
2：rmdir  /S/Q  //递归删除文件夹，不提示

权限

显而易见，只有protected和default很特殊下面就单独说一下

protected

1：同包不同类
a包A类

package com.fanyongjun.a;
//A
public class A
{
 protected void sayHello(String msg){
  System.out.println(msg);
 }
} 

a包B类

package com.fanyongjun.a;
//B
public class B
{
 public static void main(String[]args){
  A a=new A();
  a.sayHello("over");
 }  
}

操作：
编译：javac -d classes -cp classes A.java B.java
结果：
显然通过了
访问:java com.fanyogjun.a.B
结果：

2：子类的访问
A

package com.fanyongjun.a;
//A
public class A
{
 protected void sayHello(String msg){
  System.out.println(msg);
 }
}

AA
（A的子类，继承A）

package com.fanyongjun.a;
//A
public class AA extends A
{
 protected void sayHello(String msg){
  super.sayHello(msg);
  System.out.println("msg");
 }
}

B
（通过B访问AA）

package com.fanyongjun.a;
//B
public class B
{
 public static void main(String[]args){
  AA a=new AA();
  a.sayHello("over");
 }  
}

操作编译：javac -d classes -cp classes A.java AA.java B.java
结果：
显然是可以的

不同包下的protected
B

在这里插入代码片

package com.fanyongjun.a;
//B
import com.fanyongjun.c.C;
public class B
{
 public static void main(String[]args){
  //AA a=new AA();
  //a.sayHello("over");
  C c=new C();
  c.sayBye();
 }  
}

C

package com.fanyongjun.c;
//C
public class C
{
 protected void sayBye (){
  System.out.println("byebye");
 }
}

运行
操作：javac -d classes -cp classes C.java B.java
结果：

default

E1

package com.fanyongjun.e;
//E
public class E1
{ //default 修饰
 default void sayE(){
  System.out.println("EEE");
 }
}

E2

package com.fanyongjun.e;
//E2
public class E2
{
 public static void main(String[]args){
  E1 e=new E1();
  e.sayE();
 }
}

同一个包下的不同类
操作：编译：javac -cp classes -d classes E1.java E2.java
运行：java -cp classes com.fanyongjun.e.E2
结果：
结果显然可以哇
同包下的子类
代码：
E1：

package com.fanyongjun.e;
//E
public class E1
{ //default 修饰
 default void sayE(){
  System.out.println("EEE");
 }
}

E1_1(E1的子类)

package com.fanyongjun.e;
//E
public class E1_1 extends E1
{
 void sayE(){
  super.sayE();
  System.out.println("chenggongle");
 }
}

E2

package com.fanyongjun.e;
//E2
public class E2
{
 public static void main(String[]args){
  E1_1 ee=new E1_1();
  ee.sayE();
 }
}

操作：编译：javac -cp classes -d classes E1.java E1_1.java E2.java
运行：java -cp classes com.fanyongjun.e.E2

不同包下的子类

package com.fanyongjun.e2;
//E1_2
import com.fanyongjun.e.E1;
public class E1_2 extends E1
{
 void sayE(){
  super.sayE();
  System.out.println("chenggongle");
 }
}

操作：javac -cp classes -d classes E1.java E1_1.java E2.java E1_2.java
结果：E1_2.java:7: 错误: sayE()在E1中不是公共的; 无法从外部程序包中对其进行访问

打包

0.java archieve ,java归档=打包。
把所有的class文件打包成jar包
1.jar war ear har
*java–help *
示例:

 # 创建包含两个类文件的名为 classes.jar 的档案:
 jar --create --file classes.jar Foo.class Bar.class
 # 使用现有的清单创建档案, 其中包含 foo/ 中的所有文件:
 jar --create --file classes.jar --manifest mymanifest -C foo/ .
 # 创建模块化 jar 档案, 其中模块描述符位于
 # classes/module-info.class:
 jar --create --file foo.jar --main-class com.foo.Main --module-version 1.0
     -C foo/ classes resources
 # 将现有的非模块化 jar 更新为模块化 jar:
 jar --update --file foo.jar --main-class com.foo.Main --module-version 1.0
     -C foo/ module-info.class
 # 创建包含多个发行版的 jar, 并将一些文件放在 META-INF/versions/9 目录中:
 jar --create --file mr.jar -C foo classes --release 9 -C foo9 classes

主要操作：

 -c, --create               创建档案
  -i, --generate-index=FILE  为指定的 jar 档案生成
                             索引信息
  -t, --list                 列出档案的目录
  -u, --update               更新现有 jar 档案
  -x, --extract              从档案中提取指定的 (或全部) 文件
  -d, --describe-module      输出模块描述符或自动模块名称

把classes文件下的打包成myjar.jar
操作：jar cvf myjar.jar -c classes/.

然后文件夹里会有一个jar的文件，这样就成功打包成jar文件了
访问class就可以通过jar访问
访问代码：java -p myjar.jar com.fanyongjun.e.E2
上面我们是访问一个jar中的class
如果访问多个jar中的就用**;隔开
例如：java -p myjar.jar；xxx.jar com.fanyongjun.e.E2
***jar里面展现出来的一定是根包*如果不是根包会出现错误
jar
对java的类文档进行归档
//将foo目录下的所有文件进行归档，生成xxx.jarjar cvf xxx.jar -c foo/.

//归档时，指定入口点,会在清单文件中添加-class属性jar cvfe xx.jar com.fanyongjun.e.E2 -c foo/classes.
通过jar文件执行程序
1:java -cp xxx.jar com.fanyongjun.e.E2
2java -cp xxx.jar;yyy.jar;classes/.. com.fanyongjun.e.E2
3：java -jar xxx.jar