希望多多给予指点，先谢谢了。
14 个解决方案
#1
因为你要保存文件，而文件名就是这个public类。
#2
1、每个编译单元(文件)只能有一个public 类。这么做的意思是，每个编
译单元只能有一个公开的接口，而这个接口就由其public 类来表示。
你可以根据需要，往这个文件里面添加任意多个提供辅助功能的package 权限的类。但是如果这个编译单元里面有两个或两个以上的public 类的话，编译器就会报错。
2. public 类的名字必须和这个编译单元的文件名完全相同，包括大小
写。所以对Widget 类，文件名必须是Widget.java，不能是widget.java 或WIDGET.java。如果你不遵守，编译器又要报错
了。
3. 编译单元里面可以没有public 类，虽然这种情况不常见，但却是可以
的。这时，你就能随意为文件起名字了。
译单元只能有一个公开的接口，而这个接口就由其public 类来表示。
你可以根据需要，往这个文件里面添加任意多个提供辅助功能的package 权限的类。但是如果这个编译单元里面有两个或两个以上的public 类的话，编译器就会报错。
2. public 类的名字必须和这个编译单元的文件名完全相同，包括大小
写。所以对Widget 类，文件名必须是Widget.java，不能是widget.java 或WIDGET.java。如果你不遵守，编译器又要报错
了。
3. 编译单元里面可以没有public 类，虽然这种情况不常见，但却是可以
的。这时，你就能随意为文件起名字了。
#3
楼上所说的没错，但是编译单元当中为什么却又可以没有public类了呢？这样不就连一个公开的接口都没有了吗？这样有意义吗？
#4
1、每个编译单元(文件)只能有一个public 类。这么做的意思是，每个编
译单元只能有一个公开的接口，而这个接口就由其public 类来表示。
说得有道理.
编译单元中没有public类,指的是没有公开的接口,但是可以在同一个包内访问的.
public的意思是在包内包外均可访问.
译单元只能有一个公开的接口，而这个接口就由其public 类来表示。
说得有道理.
编译单元中没有public类,指的是没有公开的接口,但是可以在同一个包内访问的.
public的意思是在包内包外均可访问.
#5
楼上所说的没错，但是编译单元当中为什么却又可以没有public类了呢？这样不就连一个公开的接口都没有了吗？这样有意义吗？
---------------------------
to tanlei_accp(爱梦薇)
这时，你就能随意为文件起名字了。
---------------------------
to tanlei_accp(爱梦薇)
这时，你就能随意为文件起名字了。
#6
如果楼主还不懂，
是能请教开发JAVA的那些老师们了。
是能请教开发JAVA的那些老师们了。
#7
1、在源程序中只有一个public类，是为了让程序在执行时只从一个接口导入。如果能有多个public类，程序就无法识别该从哪里导入程序了。比如说：
import java.io.*;
class student
{
private int id;
private float score;
public student(int id,float score)
{
this.id=id;
this.score=score;
}
public int getid()
{
return this.id;
}
public float getscore()
{
return this.score;
}
}
public class stu
{
public static void main(String args[] )
{
student a = new student(1,99);`
System.out.print(a.getid()+"\t");
System.out.println(a.getscore());
}
}
这个程序，如果student也为public类，那程序如果从student类中导入，那就什么都没有，而从stu类里能正确的输出。这样就会产生矛盾，导致系统出错。所有在java中只允许有一个public类。
至于源文件名必须要与类名相同，是为了让系统更好地识别从哪个类中导入（个人见解）。
其实这是java的硬性规定。
zt_soft(Get busy living, Or get busy dying.) 3、编译单元里面可以没有public 类，虽然这种情况不常见，但却是可以的。这时，你就能随意为文件起名字了。
zt_soft(Get busy living, Or get busy dying.) 能不能试举一例呢？让我们这些初学者见识见识（例子请尽量简单些）
import java.io.*;
class student
{
private int id;
private float score;
public student(int id,float score)
{
this.id=id;
this.score=score;
}
public int getid()
{
return this.id;
}
public float getscore()
{
return this.score;
}
}
public class stu
{
public static void main(String args[] )
{
student a = new student(1,99);`
System.out.print(a.getid()+"\t");
System.out.println(a.getscore());
}
}
这个程序，如果student也为public类，那程序如果从student类中导入，那就什么都没有，而从stu类里能正确的输出。这样就会产生矛盾，导致系统出错。所有在java中只允许有一个public类。
至于源文件名必须要与类名相同，是为了让系统更好地识别从哪个类中导入（个人见解）。
其实这是java的硬性规定。
zt_soft(Get busy living, Or get busy dying.) 3、编译单元里面可以没有public 类，虽然这种情况不常见，但却是可以的。这时，你就能随意为文件起名字了。
zt_soft(Get busy living, Or get busy dying.) 能不能试举一例呢？让我们这些初学者见识见识（例子请尽量简单些）
#8
下面这段代码，文件名取什么都可以，只要后缀为.java就行！
class test1{
public static void main(String[] args){
System.out.println("test1");
}
}
class test2{
public static void main(String[] args){
System.out.println("test2");
}
}
class test1{
public static void main(String[] args){
System.out.println("test1");
}
}
class test2{
public static void main(String[] args){
System.out.println("test2");
}
}
#9
正解,其实这些都是理论上的,做实验可以通过,但是实际用处不大
其实包也是,你可以写一个没有包声明的程序,但是在实际项目中,所以的都需要声明包
这是一种规范
其实包也是,你可以写一个没有包声明的程序,但是在实际项目中,所以的都需要声明包
这是一种规范
#10
为什么在一个java源文件当中只能够有一个public类呢？
首先,楼主所说的问题所针对的情况是在“一个java源文件中包含多个类时”,这样只能够有一个public类,因为java程序的入口是main方法,所以被定为public的这个类里一定是含有main方法的类,而且该类的名称要和文件名一致,因为虚拟机开始要找main的.
在标准的java代码编写时,无论代码量多少,最好一个源文件里只有一个类或接口(接口也要单独写在一个源文件里),因为JAVA是面向对象的语言,每个类都是抽象的结果,所以每个类都要单独写在一个源文件里.
最好不要在一个.java的源文件里写很多的类.
首先,楼主所说的问题所针对的情况是在“一个java源文件中包含多个类时”,这样只能够有一个public类,因为java程序的入口是main方法,所以被定为public的这个类里一定是含有main方法的类,而且该类的名称要和文件名一致,因为虚拟机开始要找main的.
在标准的java代码编写时,无论代码量多少,最好一个源文件里只有一个类或接口(接口也要单独写在一个源文件里),因为JAVA是面向对象的语言,每个类都是抽象的结果,所以每个类都要单独写在一个源文件里.
最好不要在一个.java的源文件里写很多的类.
#11
fff
#12
for desgin,see thinking in java.
#13
我做过一个例子，带有main方法的类不是public类，而没有带main方法的类却是public类。这两个类在同一个源文件下却没有报错这是为什么？
public class publicTest
{
void show()
{
System.out.println("Hello World");
}
}
class testClass
{
public static void main(String args[])
{
publicTest pt=new publicTest();
System.out.println("The main.");
pt.show();
}
}
public class publicTest
{
void show()
{
System.out.println("Hello World");
}
}
class testClass
{
public static void main(String args[])
{
publicTest pt=new publicTest();
System.out.println("The main.");
pt.show();
}
}
#14
你那是编译，运行一下就错了。说的入口是运行入口，public class 没有main方法也可以编译通过。
#1
因为你要保存文件，而文件名就是这个public类。
#2
1、每个编译单元(文件)只能有一个public 类。这么做的意思是，每个编
译单元只能有一个公开的接口，而这个接口就由其public 类来表示。
你可以根据需要，往这个文件里面添加任意多个提供辅助功能的package 权限的类。但是如果这个编译单元里面有两个或两个以上的public 类的话，编译器就会报错。
2. public 类的名字必须和这个编译单元的文件名完全相同，包括大小
写。所以对Widget 类，文件名必须是Widget.java，不能是widget.java 或WIDGET.java。如果你不遵守，编译器又要报错
了。
3. 编译单元里面可以没有public 类，虽然这种情况不常见，但却是可以
的。这时，你就能随意为文件起名字了。
译单元只能有一个公开的接口，而这个接口就由其public 类来表示。
你可以根据需要，往这个文件里面添加任意多个提供辅助功能的package 权限的类。但是如果这个编译单元里面有两个或两个以上的public 类的话，编译器就会报错。
2. public 类的名字必须和这个编译单元的文件名完全相同，包括大小
写。所以对Widget 类，文件名必须是Widget.java，不能是widget.java 或WIDGET.java。如果你不遵守，编译器又要报错
了。
3. 编译单元里面可以没有public 类，虽然这种情况不常见，但却是可以
的。这时，你就能随意为文件起名字了。
#3
楼上所说的没错，但是编译单元当中为什么却又可以没有public类了呢？这样不就连一个公开的接口都没有了吗？这样有意义吗？
#4
1、每个编译单元(文件)只能有一个public 类。这么做的意思是，每个编
译单元只能有一个公开的接口，而这个接口就由其public 类来表示。
说得有道理.
编译单元中没有public类,指的是没有公开的接口,但是可以在同一个包内访问的.
public的意思是在包内包外均可访问.
译单元只能有一个公开的接口，而这个接口就由其public 类来表示。
说得有道理.
编译单元中没有public类,指的是没有公开的接口,但是可以在同一个包内访问的.
public的意思是在包内包外均可访问.
#5
楼上所说的没错，但是编译单元当中为什么却又可以没有public类了呢？这样不就连一个公开的接口都没有了吗？这样有意义吗？
---------------------------
to tanlei_accp(爱梦薇)
这时，你就能随意为文件起名字了。
---------------------------
to tanlei_accp(爱梦薇)
这时，你就能随意为文件起名字了。
#6
如果楼主还不懂，
是能请教开发JAVA的那些老师们了。
是能请教开发JAVA的那些老师们了。
#7
1、在源程序中只有一个public类，是为了让程序在执行时只从一个接口导入。如果能有多个public类，程序就无法识别该从哪里导入程序了。比如说：
import java.io.*;
class student
{
private int id;
private float score;
public student(int id,float score)
{
this.id=id;
this.score=score;
}
public int getid()
{
return this.id;
}
public float getscore()
{
return this.score;
}
}
public class stu
{
public static void main(String args[] )
{
student a = new student(1,99);`
System.out.print(a.getid()+"\t");
System.out.println(a.getscore());
}
}
这个程序，如果student也为public类，那程序如果从student类中导入，那就什么都没有，而从stu类里能正确的输出。这样就会产生矛盾，导致系统出错。所有在java中只允许有一个public类。
至于源文件名必须要与类名相同，是为了让系统更好地识别从哪个类中导入（个人见解）。
其实这是java的硬性规定。
zt_soft(Get busy living, Or get busy dying.) 3、编译单元里面可以没有public 类，虽然这种情况不常见，但却是可以的。这时，你就能随意为文件起名字了。
zt_soft(Get busy living, Or get busy dying.) 能不能试举一例呢？让我们这些初学者见识见识（例子请尽量简单些）
import java.io.*;
class student
{
private int id;
private float score;
public student(int id,float score)
{
this.id=id;
this.score=score;
}
public int getid()
{
return this.id;
}
public float getscore()
{
return this.score;
}
}
public class stu
{
public static void main(String args[] )
{
student a = new student(1,99);`
System.out.print(a.getid()+"\t");
System.out.println(a.getscore());
}
}
这个程序，如果student也为public类，那程序如果从student类中导入，那就什么都没有，而从stu类里能正确的输出。这样就会产生矛盾，导致系统出错。所有在java中只允许有一个public类。
至于源文件名必须要与类名相同，是为了让系统更好地识别从哪个类中导入（个人见解）。
其实这是java的硬性规定。
zt_soft(Get busy living, Or get busy dying.) 3、编译单元里面可以没有public 类，虽然这种情况不常见，但却是可以的。这时，你就能随意为文件起名字了。
zt_soft(Get busy living, Or get busy dying.) 能不能试举一例呢？让我们这些初学者见识见识（例子请尽量简单些）
#8
下面这段代码，文件名取什么都可以，只要后缀为.java就行！
class test1{
public static void main(String[] args){
System.out.println("test1");
}
}
class test2{
public static void main(String[] args){
System.out.println("test2");
}
}
class test1{
public static void main(String[] args){
System.out.println("test1");
}
}
class test2{
public static void main(String[] args){
System.out.println("test2");
}
}
#9
正解,其实这些都是理论上的,做实验可以通过,但是实际用处不大
其实包也是,你可以写一个没有包声明的程序,但是在实际项目中,所以的都需要声明包
这是一种规范
其实包也是,你可以写一个没有包声明的程序,但是在实际项目中,所以的都需要声明包
这是一种规范
#10
为什么在一个java源文件当中只能够有一个public类呢？
首先,楼主所说的问题所针对的情况是在“一个java源文件中包含多个类时”,这样只能够有一个public类,因为java程序的入口是main方法,所以被定为public的这个类里一定是含有main方法的类,而且该类的名称要和文件名一致,因为虚拟机开始要找main的.
在标准的java代码编写时,无论代码量多少,最好一个源文件里只有一个类或接口(接口也要单独写在一个源文件里),因为JAVA是面向对象的语言,每个类都是抽象的结果,所以每个类都要单独写在一个源文件里.
最好不要在一个.java的源文件里写很多的类.
首先,楼主所说的问题所针对的情况是在“一个java源文件中包含多个类时”,这样只能够有一个public类,因为java程序的入口是main方法,所以被定为public的这个类里一定是含有main方法的类,而且该类的名称要和文件名一致,因为虚拟机开始要找main的.
在标准的java代码编写时,无论代码量多少,最好一个源文件里只有一个类或接口(接口也要单独写在一个源文件里),因为JAVA是面向对象的语言,每个类都是抽象的结果,所以每个类都要单独写在一个源文件里.
最好不要在一个.java的源文件里写很多的类.
#11
fff
#12
for desgin,see thinking in java.
#13
我做过一个例子，带有main方法的类不是public类，而没有带main方法的类却是public类。这两个类在同一个源文件下却没有报错这是为什么？
public class publicTest
{
void show()
{
System.out.println("Hello World");
}
}
class testClass
{
public static void main(String args[])
{
publicTest pt=new publicTest();
System.out.println("The main.");
pt.show();
}
}
public class publicTest
{
void show()
{
System.out.println("Hello World");
}
}
class testClass
{
public static void main(String args[])
{
publicTest pt=new publicTest();
System.out.println("The main.");
pt.show();
}
}
#14
你那是编译，运行一下就错了。说的入口是运行入口，public class 没有main方法也可以编译通过。