菜鸡的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命令是最好用的，比开发工具提供的好用

菜鸡的Java笔记 第二十八 包的定义

猜你喜欢

菜鸡的Java笔记第二十八包的定义