java 不同的package下同类明的冲突以及解决办法

在一个项目中建立三个包分别为：

                                                        chapter2

                                                        pack2

                                                        pack3

                                                        

其中初始化（主）函数在InitialTelphone类里,看图显然是在chapter2包里。

这是chapter2包下的Telphone类实现

[java] view plain copy

print ?

1. package pack2;  
2.   
3. public class Telphone {  
4.      public Telphone() {  
5.         // TODO Auto-generated constructor stub  
6.          System.out.println(”第二个包的类Telphone”);  
7.     }  
8. }  

package pack2;

public class Telphone {
     public Telphone() {
        // TODO Auto-generated constructor stub
         System.out.println("第二个包的类Telphone");
    }
}

这是pack3包下的Telphone类实现

[java] view plain copy

print ?

1. package pack3;  
2.   
3. public class Telphone {  
4.    public Telphone() {  
5.     // TODO Auto-generated constructor stub  
6.        System.out.println(”第三个包的Telphone类”);  
7. }  
8. }  

package pack3;

public class Telphone {
   public Telphone() {
    // TODO Auto-generated constructor stub
       System.out.println("第三个包的Telphone类");
}
}

chapter2包下的initialTelphone类实现：

[java] view plain copy

print ?

1. package chapter2;  
2. public class InitalTelphone {  
3.   
4.     public static void main(String[] args) {  
5.         //通过无参方法生成对象  
6.      Telphone tel=new Telphone();     
7.     }  
8.   
9. }  

package chapter2;
public class InitalTelphone {

    public static void main(String[] args) {
        //通过无参方法生成对象
     Telphone tel=new Telphone();   
    }

}

在initialTelphone文件写没有导入包pack2.Telphone和pack3.Telphone

执行程序将会得到以下结果：

  第一个包的Telphone类

若在initialTelphone文件中导入pack2.telphone

intialTelphone代码改变如下：

 

[java] view plain copy

print ?

1. package chapter2;  
2. import pack2.Telphone;  
3. public class InitalTelphone {  
4.   
5.     public static void main(String[] args) {  
6.         //通过无参方法生成对象  
7.      Telphone tel=new Telphone();  
8.        
9.     }  
10.   
11. }  

package chapter2;
import pack2.Telphone;
public class InitalTelphone {

    public static void main(String[] args) {
        //通过无参方法生成对象
     Telphone tel=new Telphone();

    }

}

执行程序会发现结果为：

   第二个包的类Telphone

但是如果导入的包形式为：impor pack2.*;

[java] view plain copy

print ?

1.  package chapter2;  
2. import pack2.*;  
3. public class InitalTelphone {  
4.   
5.     public static void main(String[] args) {  
6.         //通过无参方法生成对象  
7.      Telphone tel=new Telphone();  
8.        
9.     }  
10.   
11. }  

 package chapter2;
import pack2.*;
public class InitalTelphone {

    public static void main(String[] args) {
        //通过无参方法生成对象
     Telphone tel=new Telphone();

    }

}

程序运行结果又发生了变化：

     第一个包的Telphone类

如果同时导入pack2.Telphone和pack3.Telphone

则会发生包冲突报错

The import pack3.Telphone collides with another import statement

[java] view plain copy

print ?

1. package chapter2;  
2. import pack2.Telphone;  
3. import pack3.Telphone;;  
4. public class InitalTelphone {  
5.   
6.     public static void main(String[] args) {  
7.         //通过无参方法生成对象  
8.      Telphone tel=new Telphone();  
9.         
10.     }  
11.   
12. }  

package chapter2;
import pack2.Telphone;
import pack3.Telphone;;
public class InitalTelphone {

    public static void main(String[] args) {
        //通过无参方法生成对象
     Telphone tel=new Telphone();

    }

}

但是把pack2.telphone格式改为pack2.*，pack3.Telphone保持不变

[java] view plain copy

print ?

1. package chapter2;  
2. import pack2.*;  
3. import pack3.Telphone;;  
4. public class InitalTelphone {  
5.   
6.     public static void main(String[] args) {  
7.         //通过无参方法生成对象  
8.      Telphone tel=new Telphone();  
9.      //有参构造方法生成对象  
10.      //Telphone tel2=new Telphone(4.0f,3.0f,1.5f);  
11.     }  
12.   
13. }  

package chapter2;
import pack2.*;
import pack3.Telphone;;
public class InitalTelphone {

    public static void main(String[] args) {
        //通过无参方法生成对象
     Telphone tel=new Telphone();
     //有参构造方法生成对象
     //Telphone tel2=new Telphone(4.0f,3.0f,1.5f);
    }

}

程序执行结果为：

        第三个包的Telphone类

 显然如果把pack3.Telphone格式也改为pack3.*，结果可想而知：

       第一个包的Telphone类

但是如果把chapter2中的Telphone类给删除了

导入包的格式为pack2.*；pack3.*;

运行程序就会出现冲突错误：

        The type Telphone is ambiguous
The type Telphone is ambiguous

如果只导入Pack2.*或者只导入Pack3.*则又可以运行成功：

           （import Pack2.*;）结果：第二个包的Telphone类

            （import Pack3.*;）结果：第三个包的Telphone类

通过上述程序的测试，我知道了包重名类的简单运行机制：

1   如果没有导入任何包，主函数运行时创建类的实例首先从自己所在的包里面找

2   如果导入一个包，并且导入该包的形式精确到重名的类，则主函数创建重名类实例将会从导入的包里找

3   如果导入一个包，包的格式为  import 包名.*；类型的，则主函数创建重名类实例时首先在主函数自己所在的包里找，找不到了再去导入的.*包里面找

4   如果导入多个包，并且导入的多个包中只有一个导入类型精确到重名类，则主函数创建重名类实例时在导入精确到类的包里面找。

5   如果导入多个包，并且读入的多个包中都是（import 包名.*;）类型的，主函数创建重名类实例时直接在自己所在包里找；如果找不到，并且导入的多个包里有两个同名类就会报错 ；