import语句出错

Question

首先，我都是在控制台下编译执行的，没有用IDE。
在G:\javatest 下面有两个源文件 Ss.java Demo.java（名字没有意义，是临时乱取的）
Ss.java代码如下：
package test;      
public interface Ss{
  int a=2;
  void f(  );
}
编译命令 javac -d . Ss.java                   在当前目录G:\javatest下面创建包testDemo.java代码如下：
import test.*;  
public class Demo implements Ss{
    public void  f(){
                 System.out.println("a="+a);
              }
    public static void  main(String args[]){
        Demo d=new Demo();
        d.f();    }
}
编译命令 javac Demo.java
出现错误如下：如果将红色的代码改为import test.Ss;
程序运行成功。
这是什么原因？
 

Answer 1

图片传不上来，我自己打上好了。控制台下的错误如下：
Demo.java:2: 无法访问Ss
错误的类文件： .\Ss.java
文件不包含类Ss
请删除该文件或确保该文件位于正确的类途径子目录中。
public class Demo implements Ss{
                             ^

Answer 2

那还有什么意思，现在这样就是想知道为什么会出错，放到ide。。

Answer 3

试了下 确实是有问题的 但是 如果你把 import test.*; 
 改成import test.Ss; 
就ok 这个......不知道什么问题 等待高手作答

Answer 4

Ss.java里的package test有什么用？
Ss.java 和Demo.java在同一个目录下，是不需要import的。画蛇添足了

Answer 5

Ss.java里的package test有什么用？
Ss.java 和Demo.java在同一个目录下，是不需要import的。画蛇添足了
[/Quote]本来是想验证如果interface前面不加public，包外是不是可以访问的，所以把接口放在一个包中，在包外访问的。两个已经被放到不同的包中，自然要import了。
结果验证倒是验证了，又出现这个问题了。
不管是不是画蛇添足，解释一下为什么这样会出现错误？
import test.*； 和
import test.Ss；这两个为什么一个可以，一个 不可以？

Answer 6

Demo.java:2: 无法访问Ss
错误的类文件： .\Ss.java
文件不包含类Ss
请删除该文件或确保该文件位于正确的类途径子目录中。
public class Demo implements Ss{
根据你的错误提示,把Ss.java移动到编译出来的test文件夹下面
javac Demo.java  OK了

Answer 7

大侠们，我想知道的是，为什么
import test.*； 和
import test.Ss；
这两个一个可以成功执行，一个编译都不能通过。
告诉我原因啊。。先别着急告诉我怎么解决，我需要知道原因。

Answer 8

包里面的java没编译成.class吧。。也就这个可能了我记得是class  而不是 java

Answer 9

做了个实验
假设我的目录是这样的
d:/test/Ss.java  d:/Demo.java
然后javac -verbose Demo.java
仔细看看输出
可以很清晰的看到编译器会自己去找依赖关系，把2个class同时生成了
楼主的目录是这样的 d:/test/Ss.class d:/Ss.java d:/Demo.java
javac -verbose Demo.java
你自己看下输出，编译器并没有去找你的class，他载入的是.\Ss.java，然后他就发现你这个Ss.java路径是不对的，报错了但是如果import的时候不是*的时候显然是显示的指定了应该去加载Ss.class文件所以通过编译也不知道我说清楚了没，楼主自己试试吧，仔细看看输出

Answer 10

不是很理解
我自己试了一下，看了解析过程，还是不懂，所以麻烦再讲一下。
1.为什么载入的是.\Ss.java文件而不是Ss.class文件？
2.“然后他就发现你这个Ss.java路径是不对的"路径为啥不对啊？  当前目录.下面不是有Ss.java么？
3.按照你上面给出的正确例子和目录，是不是意味着如果以后要在包外访问一个包内部的类，如果import语句导入的是.*，那么此类的源文件.java也必须在包中？

Answer 11

继续引用12楼的，我又做了一个测试
前提都是import test.*;
如果将Ss.java文件放入包test中，则javac -verbose Demo.java
编译器解析过程中装入的是 .\test\Ss.class如果将Ss.java放在不放在包test中，则javac -verbose Demo.java
编译器解析过程中转入的是.\Ss.java，所以报错没法载入.\Ss.java。求高手解释啊，为什么这样。我很困惑。。

Answer 12

我是这么理解的，也有可能不对，
你看我给出的第一个例子，我在没有编译Ss.java的情况下（只是把它放到test目录下）
javac Demo.java他直接编译出2个class，因为他会在载入Demo。java的时候搜索Ss.java一起编译了
然而classpath是从 当前目录（.）开始搜索的，所以如果test包外还有个Ss.java就会干扰到这个过程
至于你说的如果import语句导入的是.*，那么此类的源文件.java也必须在包中也是不对的
现在你是编译的时候有问题，你把编译好的class按照目录放号，无论多少java文件也干扰不到你运行（现在是javac的时候有问题）
eclipse在建java工程的时候就有2种选择，一种是把源文件和class都放在一起
还有一种是分成src和bin2个目录放
所以如果你自己javac最好还是把java文件也按照包的目录结构放（即放到test目录下去）

Answer 13

这句话什么意思？如果.java文件不在包中的话，而import语句导入的是.*，那编译的时候不就会出现我出现的问题么？

Answer 14

1.java文件按包目录放
2.不要java文件也可以（我指的是Ss.java），因为已经有了Ss.class

Answer 15

没用的。。javac -d . Ss.java就意味着讲.class文件放入包test中了，或者我直接把编译生成后的.class放到包中，只要是import导入*,都会出现这个错误，你试试

Answer 16

晕死，你还没明白我的意思，你当前目录Ss.java影响到了编译，把Ss.java放到test包下
原因前面我写了

Answer 17

我又试了一下
Ss.java文件不变，即import test.*，在Demo.java文件中加入语句package test.inside;
编译通过。似乎意味着如果Demo.java所在的包（文件夹）在他使用的类Ss.java所在的包（文件夹）的子目录下，即：如果使用的是上一层目录里面的类，那么不需要将.java文件放入包中，import *即可编译通过。
而如果Demo.java使用的类Ss.java所在的包（文件）在他Demo.java所在的包（文件）的子目录下，即：如果使用的是子目录里面的类，那么必须要将.java文件放入包中，否则import *编译报错。我写了好几个例子都是这样。。

Answer 18

要不这样，先编译Ss.java文件，然后生成Ss.class以后把Ss.java再从当前目录删掉，再编译Demo.java?

Answer 19

我把现在遇到的各种情况都汇总一下，都是在不停地实验过程中遇到的。
前提：首先，我都是在控制台下编译执行的，没有用IDE。
在G:\javatest 下面有两个源文件 Ss.java Demo.java（名字没有意义，是临时乱取的）
Ss.java代码如下：
package test;   
public interface Ss{
  int a=2;
  void f( );
}
编译命令 javac -d . Ss.java 在当前目录G:\javatest下面创建包testDemo.java代码如下：
import test.*; 
public class Demo implements Ss{
  public void f(){
  System.out.println("a="+a);
  }
  public static void main(String args[]){
  Demo d=new Demo();
  d.f();   }
}
编译命令 javac Demo.java
首先，我都是在控制台下编译执行的，没有用IDE。
在G:\javatest 下面有两个源文件 Ss.java Demo.java（名字没有意义，是临时乱取的）
Ss.java代码如下：
package test;   
public interface Ss{
  int a=2;
  void f( );
}
编译命令 javac -d . Ss.java 在当前目录G:\javatest下面创建包testDemo.java代码如下：
import test.*; 
public class Demo implements Ss{
  public void f(){
  System.out.println("a="+a);
  }
  public static void main(String args[]){
  Demo d=new Demo();
  d.f();   }
}
编译命令 javac Demo.java
首先，我都是在控制台下编译执行的，没有用IDE。
在G:\javatest 下面有两个源文件 Ss.java Demo.java（名字没有意义，是临时乱取的）
Ss.java代码如下：
package test;   
public interface Ss{
  int a=2;
  void f( );
}
编译命令 javac -d . Ss.java 在当前目录G:\javatest下面创建包testDemo.java代码如下：
import test.*; 
public class Demo implements Ss{
  public void f(){
  System.out.println("a="+a);
  }
  public static void main(String args[]){
  Demo d=new Demo();
  d.f();   }
}
编译命令 javac Demo.java
首先，我都是在控制台下编译执行的，没有用IDE。
在G:\javatest 下面有两个源文件 Ss.java Demo.java（名字没有意义，是临时乱取的）
Ss.java代码如下：
package test;   
public interface Ss{
  int a=2;
  void f( );
}
编译命令 javac -d . Ss.java 在当前目录G:\javatest下面创建包testDemo.java代码如下：
import test.*; 
public class Demo implements Ss{
  public void f(){
  System.out.println("a="+a);
  }
  public static void main(String args[]){
  Demo d=new Demo();
  d.f();   }
}
编译命令 javac Demo.java
控制台下的错误如下：
Demo.java:2: 无法访问Ss
错误的类文件： .\Ss.java
文件不包含类Ss
请删除该文件或确保该文件位于正确的类途径子目录中。
public class Demo implements Ss{
                              ^问题1：如果将红色的代码改为import test.Ss;
编译通过，
java Demo
成功执行。
这是什么原因？针对上面这个错误，下面稍作改动。
问题2：红色代码保持不变
将Ss.java放到包test里面，然后
javac -d . Ss.java
javac Demo.java
编译通过，
java Demo
成功执行。问题3：红色代码保持不变
首先javac -d . Ss.java，此时在test中生成了Ss.class，然后将Ss.java删除，
javac Demo.java
编译通过，
java Demo
成功执行问题4：红色代码保持不变
在Demo.java文件中加入语句package test.inside;即在包test下创建子包inside
首先javac -d . Ss.java，
然后javac -d . Demo.java，
编译通过，
java test.inside.Demo
成功执行。
问题4我有这样的想法，不知道对不对
如果Demo.java所在的包（文件夹）在他使用的类Ss.java所在的包（文件夹）的子目录下，即：如果使用的是上一层目录里面的类，那么不需要将.java文件放入包中，import *即可编译通过。
而如果Demo.java使用的类Ss.java所在的包（文件）在他Demo.java所在的包（文件）的子目录下，即：如果使用的是子目录里面的类，那么必须要将.java文件放入包中，否则import *编译报错。

Answer 20

类加载造成的，要加载一个类，就是在使用一个类的时候并且在JVM中还没有这个类的信息，import packageName.*; 这种import方式并没有使用任何的类，在遇到这样的import语句时，并没有加载packageName包下的类，import packageName.ClassName; 这种import方式使用了类名为ClassName的类，遇到import语句时就加载packageName.ClassName类了。
LZ的代码应该是这样组织的：
  G:\javatest\Ss.java
  G:\javatest\Demo.java
  G:\javatest\test\Ss.class如果用import test.*;,在编译Demo.java的时候，在分析到implements 的时候才去加载Ss类，这个时候编译就会在CLASSPATH，在与Demo.java相同的目录下就找到了Ss.java，所以就编译Ss.java，可是和Demo.java不同包，所以编译通不过，而用import test.Ss;在编译的时候在分析import的时候就加载了而且包名、路径都正确，之后在用Ss的时候就不会在去找Ss.java了。这就是#12使用-verbose看到的情况了。