菜鸡的Java笔记 第二十八

包的主要作用以及定义
    包的导入操作
    系统常见的开发包
    jar 程序命令
    
    包的定义
        在任何的操作系统之中都有一个统一的共识：同一个目录下不能够存在有相同的文件名称
        但是在实际的开发之中又不可能出现不重名的情况
        所以为了解决这样的冲突问题，在项目里面往往会引用包的概念，而所谓的包存储的就是一个文件夹
        也就是说在不同的目录中可以存放有相同的文件
        如果要想在javac中定义包，直接使用 package 关键字即可
        范例：定义包

    package cn.mldn.demo; // 包名称
    public class packageDefinition{
        public static void main(String args[]){
            System.out.println("浪");
        }
    }

           
            一旦程序中声明了包，那么就必须生成的*.class 文件保存在包里面
            这个包并不是手工创建的，在java里面考虑到了用户开发所需要的种种情况，所以专门提供有打包编译的操作
        范例：打包编译
            打开控制台.......
            java -d . Hello.java
            
            在以上的编译命令中有两个参数：
                "-d" :生成目录，默认情况下是根据 package 定义的内容生存
                "." ：生成程序的保存路径，如果设置为 "." 表示当前目录下保存
            此时如果程序有包了，那么在解释程序ude时候必须加上包名称，也就是说此时的 packageDefinition 类包执行
            java cn.mldn.demo.packageDefinition
            
            所有的java项目开发过程之中，程序类必须要有包的定义才可以使用，没有包的类不存在。而类的完整名称“包.类”
            
    
    包的导入操作
        利用程序包可以将一个很多的 *.class 类归类保存起来，但是这样一来就有可能出现包与包之间进行类的互相调用问题
        所以此时就可以利用 import 语句来解决
        范例：定义一个 cn.mldn.util.Message 的类

    package cn.mldn.util; // 包名称
    class Message{
        public String getInfo(){
            return "..................";
        }
    }

           
        范例：定义一个 packageDefinition

    package cn.mldn.test;
    import cn.mldn.util.Message; // 导入其他包的类
    public class packageDefinition{
        public static void main(String args[]){
            Message msg = new Message();
            System.out.println(msg.getInfo);
        }
    }

            现在的程序肯定是需要进行编译，但是从理论上来讲应该先编译 Message.java ,而后再编译 packageDefinition.java
            于是按照此顺序编译
            编译出错： Message 在 cn.mldn.util 中不是公共的：无法从外部程序包对其进行访问
            之所以造成此问题，是因为此时的 Message 类的定义中使用的是默认的访问控制权限，而这个权限的特点是指同一包中的类可以互相访问
            但是不能够被外包所访问，所以学习完包的定义之后对于代码也可以进行一些规范化要求：
            以后写的类都要写在包中，而包中的  *.java 文件 里面只会有一个 public class 声明
            总结：关于 public class 与 class 声明类的区别？
                public class 定义要求文件名称与类名称保持一致，而在 *.java 文件之中只允许有一个 public class 定义，如果该类要被不同的包所使用，则必须使用 public class 声明
                class 定义的类文件名称可以与类名称不一致，但那是在编译之后每个 class 声明的类都会生成一个 *.java 文件，此类只能够在一个包中使用
                
        范例：修改Message 类的定义

    package cn.mldn.util; // 包名称
    public class Message{
        public String getInfo(){
            return "..................";
        }
    }

           
            现在发现多个程序编译的时候要考虑编译顺序，那么这实在是太麻烦了，所以为了方便编译，可以使用“*.java”进行自动顺序编译：javac -d . *.java
            
        但是现在的代码出现了两个问题：
            问题一：每次都是单独导入特定的类：
                import cn.mldn.util.Message;
                在进行导入的时候都需要写上完整的类名称，那么假设说现在在 cn.mldn.util 包中存在有500个类，并且本次项目需要导入20个类，难道要写20个 import 吗？
                这样就很麻烦了。所以可以使用通配符“*”完成： import cn.mldn.util.*;
                使用 import 包.* 的情况并不会将一个包中所有的类都导入进来，包括所谓的类加载的时候实际上只会加载所需要的类，不需要的类不加载
            问题二：有可能在同一个程序中导入不通过的包，但是这不同的包有相同的类，现在模拟环境：
                现在有类一： cn.mldn.util.Message;
                现在有类二：com.yootk.Message;
                

    package cn.mldn.util; // 包名称
    public class Message{
        public void show(){
            System.out.println("------------------");
        }
    }

       
                随后编译第二个 Message 程序类： javac -d . Message.java
                范例：在 packageDefinition 类中由于某种需要同时导入了两个包

    package cn.mldn.test;
    import cn.mldn.util.*; // 导入其他包的类
    import com.yootk.*;
    public class packageDefinition{
        public static void main(String args[]){
            Message msg = new Message();
            System.out.println(msg.getInfo);
        }
    }

                   
                结果出错
                为了避免使用中的类冲突，那么就建议在操作类的时候直接写上类的完整名称
                范例：使用完整名称避免错误

    package cn.mldn.test;
    import cn.mldn.util.*; // 导入其他包的类
    import com.yootk.*;
    public class packageDefinition{
        public static void main(String args[]){
            cn.mldn.util.Message msg = new cn.mldn.util.Message();
            System.out.println(msg.getInfo);
        }
    }

                   
                    这种情况在开发之中一定会出现许多次，所以用的时候就写上完整名称
                    编写顺序： package, import, public class
            
    系统常见包
        java 的开发类库非常的庞大，而开发包也非常的多，比较常见的几个包如下：
            java.lang：像 Object,String Intger,Number 都是这个包中定义的，从JDK 1.1 开始自动导入
            java.reflect：反射开发包，直接与框架开发有关系
            java.util： java的 工具包
            java.regex：正则表达式的开发包
            java.text：国际化程序支持包
            java.io：数据流的开发包（Input，Output），前提是要弄懂抽象类就差不多学会这个包
            java.net：网络编程包
            java.spl：数据库的编程包
            java.awt，javax.swing：图像界面开发包
                java在JDK1.0 的时候只提供有java.的 开发包，这个开发包可以实现图像界面的开发，最初的设计较为仓促要大量的使用Windows的系统函数
                在JDK 1.2（java2）推出了轻量级的组件，有了swing开发组件
            java.applet.*：是在网页上嵌入的java程序，是java发展的标志

    jar 命令
        当一个项目开发完成之后，虽然不同功能的类要要存在不同的包里面，但是这里面也会出现一个问题，你不可能将所有的*.class 文件给用户
        往往有可能是若干个*.class文件完成某一特定的功能组合，那么如果要更新也只会更新这几个文件
        所以在实际的项目中为了方便管理，往往会利用jar文件负责处理
        范例：；现在有个packageDefinition。java类

    package cn.mldn.util;
    public class packageDefinition{
        public String getInfo(){
            return "**************";
        }
    }

            1.进行打包编译：javac -d . packageDefinition.java;
            2.将开发包打成 pd。jar 文件：jar -cvf pd.jar cn
            打成的pd.jar 文件可以通过rar压缩文件打开，而后在这个文件里面会存在有一个文件夹：META-INF/MANFEST.MF
            3.当程序打包完成之后肯定需要进行代码的执行，肯定需要编写测试类

    package cn.mldn.test;
    public class packageDefinition{
        public static void main(String args[]){
            cn.mldn.util.Message msg = new cn.mldn.util.Message();
            System.out.println(msg.getInfo);
        }
    }
    //出错

                   
            实际上每个jar文件都是一个独立的路径，所以要想让jar文件起作用，必须配置CLASSPATH,但是CLASSPATH 中有一个“.” ，所以如果要想配置多个CLASSPATH 使用“;”分割
            SET CLASSPATH = .;(文件目录)
            
            以上的配置只能够在当前命令行中使用，如果要想让其成为全局的配置，则需要修改环境属性
            如果现在只使用记事本开发程序，那么所有需要的第三方的*.jar 文件啊都必须在环境属性配置
            
            
    总结
        1.以后的程序都要写上 package 打包
        2.import 语句往往不需要编写，前提：使用开发工具
        3.jar命令是最好用的，比开发工具提供的好用