java 依赖倒置代码 java倒包语句

开发过程中，可能会造成类名重复的问题，然后编译覆盖前面编译的东西。

包：相当于是Windows中的文件夹

定义包的格式：

package 包名;

包名命名规范：包名全部小写。

包语句要注意的事项：

1. package语句必须位于java文件中中第一个语句，之前不能有其他任何代码语句

2. 如果一个类加上了包语句，那么该类的完整类名就是: 包名.类名（加一个相应包文件，然后把相应文件复制进去。然后运行还需要包名.类名,这段话还没有升级），注意你的java文件不一定要放到包下，主要是针对于class类文件，它的包是自动创建的

这段话怎么来验证一把，这个是升级之后

3. 一个java文件只能有一个包语句，但是导包语句不一定。

问题：  每次编译的时候都需要自己创建一个文件夹（是需要手工创建你的啊），把对应 的class文件存储 到文件夹中。特别麻烦这里我们就要用javac，其实javac也挺麻烦 的，javac -d ./ 编译文件（这个包文件就是自己创建的，就算是存在，也是自己创建的）

下面来说一下包的作用：

1.解决类名产生冲突的问题

2.便于软件版本的发布

没有包的时候，JAVA文件与class文件放在一个地方了。然后发布出去，别人直接可以用你的源代码。

有包的时候，直接把class文件打包。

apk里面全部是class文件。查看里面的压缩包，然后反编译，往里面插入一条广告。这里import要放在package下面。

问题： 有了包之后类与类之间的访问每次都必须 要写上包名，特别的麻烦

两个不同的文件，从一个文件主类调用另外一个类中的方法。

上面就是包名.类名

比较麻烦的就是这个东西，上面如果不采用导包语句，类与类之间的访问都要带上包名

解决方案： sum提供导包语句让我们解决该问题。8

导包语句作用：简化书写。 (误区： 把一个类导入到内存中)

导包语句的格式：

 import 包名.类名;   （导入xxx包中某个类）

上面直接导的包，没有问题。

导包语句要注意的细节：

1.一个java文件可以有很多个导包语句

2."*"是 导包语句的通配符。可以匹配任何 的类名。

假如一个aa包里面有20几个类，我就用到aa包里面十几个类

import  aa.*

 3. import aa.*; *是不会作用于aa包下面的子包的。

*只能匹配类名，不能匹配包名。

推荐使用：import 包名.类名;   因为使用*通配符会导致结构不清晰。

import aa.ww

import aa.*:这个的意义，绝对不是把所有类加载到内存里面。类文件被加载到内存会自动执行静态代码块的方法，自动执行，分别在两个demo文件，放入两个静态代码块。使用到才会加载进去。

写代码验证一下上面这句话：

在同一个包下面，放了两个类文件，下面是两个类文件的源代码 ：

第一个Test1.java

package aa;
public class Test1{
     //写一个排序
     public static void bubbleSort(int[] arr){
         int temp = 0;
         int n = arr.length;
         for(int i = 0;i < n - 1;i++){
             for(int j = 0;j < n - 1 - i;j++){
                 if(arr[j] > arr[j+1]){
                     //前面的数据大于后面的数据，交换位置
                     temp = arr[j];
                     arr[j] = arr[j+1];
                     arr[j+1] = temp;
                 }
             }
         }
     }
     
     static{
             System.out.println("Test1类跑起来了...");
     }
 }下面是Test2.java的源代码：
package aa;
public class Test2{
     //变成字符串
     public static String myselfToString(int[] arr){
         String res = "";
         for(int i = 0;i < arr.length;i++){
             if(i == 0){
                 res += "[" + arr[i] + ",";
             }else if(i == (arr.length -1)){
                 res += arr[i] + "]";
             }else{
                 res += arr[i] + ",";
             }
         }
         return res;
     }
     static{
         System.out.println("Test2类跑起来了....");
     }   
 }

然后在另外一个文件中：

import aa.Test1;
 import aa.Test2;class Demo75{
     public static void main(String[] args){
             int[] arr = {4,3,2,1};
             for(int i = 0;i < arr.length;i++){
                 System.out.println(arr[i]);
             }
             System.out.println();
             //调用某个包下面的类，然后调用了里面的静态方法
             Test1.bubbleSort(arr);
             for(int i = 0;i < arr.length;i++){
                 System.out.println(arr[i]);
             }
             String res = Test2.myselfToString(arr);
             System.out.println(res);
     }
 }

然后让代码跑起来了，上面很明显就是类文件被用到了，才会加载到内存里面。

两个文件在同一个包，不需要导包。但是能不能调用的问题，是根据权限修饰符决定的

什么时候使用import语句:（两个类在不同包一定导包）

两个类在不同的包的时候，就需要导包语句。

Java.lang包里面的所有类是不需要加入导包语句的

java中的权限修饰符

下面说一下打jar包：

不会直接把class文件交给用户，class文件需要编译，但是用户不会编译

JDK开发工具：jar.exe工具

上面就是用jar进行打jar包的操作，我们一次可以打多个文件夹

jar  cvf  jar文件的名字  class文件或者是文件夹 (cvf里面包含错误信息，指定文件名字)

打包一个qq.jar包的文件

对于双击图形界面启动程序来说，我们必须配置一个主入口类文件

打开上面文件内容，添加主入口

Main-Class:  qq.Demo9 :这种格式不能有偏差，中间有一个空格。

打jar包的作用：

1.图形界面，一次性提供功能类文件，如果打jar包是一个图形界面，我们就必须配置一个主入口类文件，方便快速启动一个项目

2.打jar包让别人使用，因为包太多，太乱，我们不可能一个文件夹，一个文件夹的给用户，这种情况，不用配置主入口类文件，提供功能类供用户使用

下面演示一下打jar包，提供功能类，供用户使用：

在两个包下面写上三个功能类：

aa包下面两个   bb包下面一个

package aa;
public class Test1{
     //写一个排序
     public static void bubbleSort(int[] arr){
         int temp = 0;
         int n = arr.length;
         for(int i = 0;i < n - 1;i++){
             for(int j = 0;j < n - 1 - i;j++){
                 if(arr[j] > arr[j+1]){
                     //前面的数据大于后面的数据，交换位置
                     temp = arr[j];
                     arr[j] = arr[j+1];
                     arr[j+1] = temp;
                 }
             }
         }
     }
     
     static{
             System.out.println("Test1类跑起来了...");
     }
 }

上面是冒泡排序法，这个是Test1.java文件，放在aa包里面

下面是把数组变成字符串的功能，这个是Test2.java,这个也是放在aa包里面

package aa;
public class Test2{
     //变成字符串
     public static String myselfToString(int[] arr){
         String res = "";
         for(int i = 0;i < arr.length;i++){
             if(i == 0){
                 res += "[" + arr[i] + ",";
             }else if(i == (arr.length -1)){
                 res += arr[i] + "]";
             }else{
                 res += arr[i] + ",";
             }
         }
         return res;
     }
     static{
         System.out.println("Test2类跑起来了....");
     }
 }

上面都是aa包下面的功能类，然后都写上了一个静态代码块

下面我们在bb包写上一个功能类，快速排序法：

package bb;
/*
 *快速排序法
 */
 public class Test3{
     //分区
     public static int getDiviedIndex(int[] arr,int low,int high){
         int temp = 0;
         int pivot = arr[low];
         while(low < high){
             while((low < high) && (arr[high] > pivot)){
                 high--;
             }
             temp = arr[high];
             arr[high] = arr[low];
             arr[low] = temp;
             while((low < high) && (arr[low] < pivot)){
                 low++;
             }
             temp = arr[low];
             arr[low] = arr[high];
             arr[high] = temp;
         }
         if(low == high){
             arr[low] = pivot;
         }
         return low;
     }    public static void quickSort(int[] arr,int low,int high){
         if(low < high){
             int middleValue = getDiviedIndex(arr,low,high);
             quickSort(arr,low,middleValue - 1);
             quickSort(arr,middleValue +1,high);
         }
     }
 }

然后我们把aa与bb里面的功能进行打jar包：

jar cvf mytool.jar aa bb

然后我们要想使用jar包，就必须在原先classpath后面加上jar包的路径

CLASSPATH=.;D:\java\javase\code;.\mytool.jar

上面配置了之后，就可以用了