JAVA学习基础之包及访问控制权限

　　第八章、包及访问控制权限
　　8-1、包的定义及导入
　　package是在使用多个类或接口时，为了避免名称重复而采用的一种措施，直接在程序中加入package关键字即可。包的定义格式：
　　package 包名称.子包名称；package org.lxh.demo08 ; // 定义一个包
　　class Demo{
　　public String getInfo(){
　　return ＂Hello World!!!＂ ;
　　}
　　};
　　public class PackageDemo01{
　　public static void main(String args[]){
　　System.out.println(new Demo().getInfo());
　　}
　　};
　　一个包其实就是一个文件夹，定义包之后，会生成一个名为org的文件夹，里面就有两个类文件。执行程序打包命令：
　　javac –d . PackageDemo01.java
　　程序编译完成后会生成一个名为org的文件夹，里面会生成一个Demo.class和PackageDemo01.class的两个类文件。生成完*.class之后就可以直接访问了：
　　java org.lxh.demo08.PackageDemo01
　　8-2、包的导入
　　当一个包的class文件需要使用另外一个包的class文件的时候就需要使用导入指令。在之前的程序中，两个类是存放在一个包中的，因此代码与之前没有什么根本的不同，但是如果几个类存放在不同的包中，则在使用类的时候就必须通过import语句导入。
　　语法：
　　·import 包名称.子包名称.类名称； 手工导入所需要的类
　　·import 包名称.子包名称.*；   由JVM自动加载所需要的类
　　Demo.java：package org.lxh.demo08.c ;
　　public class Demo{
　　public String getContent(){
　　return ＂MLDN LXH＂ ;
　　}
　　};
　　ImportDemo01.java：package org.lxh.demo08.b ; // 放在不同的包中
　　import org.lxh.demo08.a.* ; // 导入不同包中的Demo类
　　public class ImportDemo01{
　　public static void main(String args[]){
　　System.out.println(new Demo().getContent ()) ;
　　}
　　};
　　编译的时候应该先编译Demo.java类，之后再编译ImportDemo01.java，因为后者使用了前者的类进行操作。
　　编译ImportDemo01.java的时候出现了以下的错误提示：ImportDemo01.java:2: 错误: 程序包org.lxh.demo08.a不存在
　　import org.lxh.demo08.a.* ; // 导入不同包中的Demo类
　　^
　　ImportDemo01.java:5: 错误: 找不到符号
　　System.out.println(new Demo().getInfo()) ;
　　^
　　符号: 类 Demo
　　位置: 类 ImportDemo01
　　2 个错误
　　也就是说Demo类如果需要被外包访问的时候需要定义成public class，修改Demo类：package org.lxh.demo08.a;
　　public class Demo{
　　public String getContent (){
　　return ＂Hello World!!!＂;
　　}
　　}
　　关于public class与class声明类：
　　如果一个类声明为public class则文件名称必须与类名称一致，而且在一个类中只能有一个public class，而如果使用class声明一个类，则文件名称可以与类名称不一致，但是执行的时候必须执行生成的class文件名称。除了这些之外，public class和class还在包的访问上有所限制，如果一个类只在本包中访问，不需要被外包访问，则直接声明成class即可，而如果一个类需要被外包访问，则必须声明为public class。
　　以上的操作是明确的使用了包.类名称的方式导入的，如果现在假设要导入一个包中的很多类，这样写肯定很麻烦，我们可以直接使用＂*＂的方式进行导入：package org.lxh.demo08.b ; // 放在不同的包中
　　import org.lxh.demo08.a.* ; // 导入不同包中的Demo类
　　public class ImportDemo01{
　　public static void main(String args[]){
　　System.out.println(new Demo().getInfo()) ;
　　}
　　};
　　上面两种导入语句哪种性能更高呢？
　　·第一种：import org.lxh.demo08.a.Demo;
　　·第二种：import org.lxh.demo08.a.*；
　　实际上这两种的性能都是一样的，因为如果使用后者，是由JVM帮助用户判定需要导入的类，不需要的类，是不会被加载进来的。
　　但是在导包的时候也需要注意另外一个问题，如果现在导入了不同包的同名类的时候，则就有可能出现不明确的错误信息。package org.lxh.demo08.c ;
　　public class Demo{
　　public String getContent(){
　　return ＂MLDN LXH＂ ;
　　}
　　};
　　现在在org.lxh.demo08.a中有一个Demo类，在org.lxh.demo08.b中也有一个Demo类，之后定义一个类，需要同时导入a 和 c的包。package org.lxh.demo08.d ;
　　import org.lxh.demo08.a.* ; // 包中存在Demo类
　　import org.lxh.demo08.c.* ; // 包中存在Demo类
　　public class ImportDemo02{
　　public static void main(String args[]){
　　Demo d = new Demo() ;
　　System.out.println(d.getContent ()) ;
　　}
　　};
　　编译出错：ImportDemo02.java:6: 错误: 对Demo的引用不明确, org.lxh.demo08.c中的类 org.lxh.demo08.c.Demo和org.lxh.demo08.a中的类 org.lxh.demo08.a.Demo都匹配
　　Demo d = new Demo() ;
　　^
　　ImportDemo02.java:6: 错误: 对Demo的引用不明确, org.lxh.demo08.c中的类 org.lxh.demo08.c.Demo和org.lxh.demo08.a中的类 org.lxh.demo08.a.Demo都匹配
　　Demo d = new Demo() ;
　　^
　　2 个错误
　　所以此时，如果出现这样情况的话，则最好写入完整的＂包.类名称＂。
　　修改代码：package org.lxh.demo08.d ;
　　import org.lxh.demo08.a.* ; // 包中存在Demo类
　　import org.lxh.demo08.c.* ; // 包中存在Demo类
　　public class ImportDemo02{
　　public static void main(String args[]){
　　org.lxh.demo08.a.Demo d = new org.lxh.demo08.a.Demo () ;
　　System.out.println(d.getContent ()) ;
　　}
　　};
　　8-3、系统常见包
　　名称
　　作用
　　1
　　java.lang
　　此包为基本包，像String这样的类就都保存在此包之中，在JDK1.0的时候如果想编写程序，则必须手工导入此包，但是随后的JDK解决了此问题，所以此包现在为自动导入。
　　2
　　java.lang.reflect
　　此包为反射机制的包，是java.lang的子包，在JAVA常用类库中会介绍。
　　3
　　java.util
　　此包为工具包，一些常用的类库、日期操作等都在此包中。
　　4
　　java.text
　　提供了一些文本的处理类库
　　5
　　java.sql
　　数据库操作包，提供了各种数据库操作的类和接口。
　　6
　　java.net
　　完成网络编程
　　7
　　java.io
　　输入、输出处理
　　8
　　java.awt
　　包含了构成抽象窗口工具集（abstract window toolkits）的多个类，这些类被用来构建和管理应用程序的图形用户界面（GUI）
　　9
　　javax.swing
　　此包用于建立图形用户界面，此包中的组件相对于java.awt包而言是轻量级组件
　　8-4、静态导入
　　如果一个类中的方法全部是使用static声明的静态方法，则在导入的时候就可以直接使用＂import static＂的方式导入，导入的格式如下：
　　import static 包.类.*;package org.lxh.demo08.e ;
　　public class Operate{ // 里面的方法全部都是static类型
　　public static int add(int i,int j) { // 加法操作
　　return i + j ;
　　}
　　public static int sub(int i,int j) { // 减法操作
　　return i - j ;
　　}
　　public static int mul(int i,int j) { // 乘法操作
　　return i * j ;
　　}
　　public static int p(int i,int j) { // 除法操作
　　return i / j ;
　　}
　　};
　　如果按之前的import导入的话，则调用的时候肯定使用的是类.方法（）。package org.lxh.demo08.f ;
　　import static org.lxh.demo08.e.Operate.* ; // 静态导入
　　public class StaticImportDemo{
　　public static void main(String args[]){
　　System.out.println(＂3 + 3 = ＂ + add(3,3)) ; // 直接调用静态方法
　　System.out.println(＂3 - 2 = ＂ + sub(3,2)) ; // 直接调用静态方法
　　System.out.println(＂3 * 3 = ＂ + mul(3,3)) ; // 直接调用静态方法
　　System.out.println(＂3 / 3 = ＂ + p(3,3)) ; // 直接调用静态方法
　　}
　　};
　　8-5、jar命令
　　当开发者为客户开发出了一套JAVA类之后，肯定要把这些类交给用户使用，但是如果所有的类是直接通过*.class的格式给用户，则会比较麻烦，所以一般情况下会将这些*.class文件压缩成一个文件交付给客户使用，那么这样的文件就称为jar文件（Java Archive File），如果要想生成jar文件，直接使用JDK中bin目录里的jar.exe就可以将所有的类文件进行压缩。
　　JAR命令中的主要参数：
　　· ＂C＂：创建新的文档
　　· ＂V＂：生成详细的输出信息
　　· ＂F＂：指定存档的文件名用法: 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/。
　　例：package org.lxh.demo08.demo ;
　　public class Hello{
　　public String getInfo(){
　　return ＂Hello World!!!＂ ;
　　}
　　};
　　将其打包编译：javac –d . Hello.java
　　将其打成jar包：jar –cvf my.jar org已添加清单
　　正在添加: org/(输入 = 0) (输出 = 0)(存储了 0%)
　　正在添加: org/lxh/(输入 = 0) (输出 = 0)(存储了 0%)
　　正在添加: org/lxh/demo08/(输入 = 0) (输出 = 0)(存储了 0%)
　　正在添加: org/lxh/demo08/Demo.class(输入 = 300) (输出 = 237)(压缩了 21%)
　　正在添加: org/lxh/demo08/PackageDemo01.class(输入 = 510) (输出 = 332)(压缩了 34%
　　)
　　正在添加: org/lxh/demo08/c/(输入 = 0) (输出 = 0)(存储了 0%)
　　正在添加: org/lxh/demo08/c/Demo.class(输入 = 290) (输出 = 229)(压缩了 21%)
　　正在添加: org/lxh/demo08/a/(输入 = 0) (输出 = 0)(存储了 0%)
　　正在添加: org/lxh/demo08/a/Demo.class(输入 = 290) (输出 = 229)(压缩了 21%)
　　正在添加: org/lxh/demo08/d/(输入 = 0) (输出 = 0)(存储了 0%)
　　正在添加: org/lxh/demo08/d/ImportDemo02.class(输入 = 521) (输出 = 341)(压缩了 34
　　%)
　　一个jar包如果要想使用的话，则必须配置classpath路径。
　　set classpath=;F:网页李兴华20801_【第8章：包及访问控制权限】_包的定义及导入代码my.jar
　　例：package org.lxh.demo08 ;
　　import org.lxh.demo08.demo.Hello ;
　　public class ImportJarDemo{
　　public static void main(String args[]){
　　Hello hello = new Hello() ;
　　System.out.println(hello.getInfo()) ;
　　}
　　};
　　8-6、访问控制权限及命名规范
　　8-6-1、访问控制权限
　　Java中存在四种访问权限：
　　·private访问权限
　　·default（默认）访问权限
　　·protected访问权限
　　·public访问权限
　　范围
　　private
　　default
　　protected
　　public
　　同一类
　　同一包中的类
　　不同包的子类
　　其他包中的类
　　private：可以定义方法，属性，定义的方法和属性不能被类的外部所看到。
　　default：可以在本包中的任意地方访问。
　　protected：保护，不同包的非子类不可以访问。
　　public：公共的，都可以访问，不受任何的限制。package org.lxh.demo08.g ;
　　public class HelloDemo{
　　protected String name = ＂LXH＂ ; // 只能在本包及不同包的子类中访问
　　};
　　在其他包中访问此类中的属性。package org.lxh.demo08.h ;
　　import org.lxh.demo08.g.HelloDemo ;
　　class SubHelloDemo extends HelloDemo{
　　public void print(){
　　System.out.println(＂访问受保护属性：＂ + super.name) ;
　　}
　　};
　　public class ProtectedDemo01{
　　public static void main(String args[]){
　　SubHelloDemo sub = new SubHelloDemo() ;
　　sub.print() ;
　　}
　　};
　　如果现在没有使用子类，而是直接在不同类中访问，则会出现无法访问的错误。package org.lxh.demo08.h ;
　　import org.lxh.demo08.g.HelloDemo ;
　　public class ProtectedDemo02{
　　public static void main(String args[]){
　　HelloDemo sub = new HelloDemo() ;
　　System.out.println(sub.name) ; // 错误的，不同包的类无法访问
　　}
　　};
　　编译时出现下面的错误提示信息：ProtectedDemo02.java:6: 错误: name可以在HelloDemo中访问protected
　　System.out.println(sub.name) ; // 错误的，不同包的类无法访问
　　^
　　1 个错误
　　当产生了一个类之后，为了保证类中的内容不被外部直接看到，则使用private关键字。
　　但是，如果现在两个有关系的类要进行属性互相访问的话就比较麻烦，之前只能使用getter/setter取得和设置，所以为了减少私有属性的访问的麻烦，使用了内部类，但是内部类本身会破坏程序的结构。
　　为了让一个类的内容可以继续方便的时候访问，使用了继承的概念，但是在继承中private属性也是无法被子类看到的，所以此时，为了方便子类的操作，可以将属性使用protected进行封装，这样一来外部也无法直接看到（不同包）。
　　既然有了继承的关系，就可以使用向上或向下的转型操作，以完成多态性，但是在开发中类与类之间的直接继承并不多见，而往往继承抽象类或实现接口，当若干个操作间需要耦合的时候就可以使用接口完成。
　　既然有内部类，则如果一个接口或抽象类的子类只使用了次，则可以将其定义成匿名内部类。
　　开发中没有包的类是绝对不存在的。
　　封装 继承 多态.
　　8-6-2、java的命名规范
　　在JAVA中，声明类、方法、属性等都是有一定的规范的，此规范如下所示：
　　·类：所有单词的首字母大写，如：TestJava
　　·方法：第一个单词的首字母小写，之后每个单词的首字母大写，如：getInfo();
　　·属性：第一个单词的首字母小写，之后每个单词的首字母大写，如：studentName
　　·包：所有单词的字母小写，如：org.lxh.demo
　　·常量：所有单词的字母大写，如：FLAG