连连看java源代码
创新互联长期为千余家客户提供的网站建设服务，团队从业经验10年，关注不同地域、不同群体，并针对不同对象提供差异化的产品和服务；打造开放共赢平台，与合作伙伴共同营造健康的互联网生态环境。为邗江企业提供专业的网站建设、成都网站建设，邗江网站改版等技术服务。拥有十年丰富建站经验和众多成功案例,为您定制开发。
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
public class lianliankan implements ActionListener
{
JFrame mainFrame; //主面板
Container thisContainer;
JPanel centerPanel,southPanel,northPanel; //子面板
JButton diamondsButton[][] = new JButton[6][5];//游戏按钮数组
JButton exitButton,resetButton,newlyButton; //退出，重列，重新开始按钮
JLabel fractionLable=new JLabel("0"); //分数标签
JButton firstButton,secondButton; //分别记录两次被选中的按钮
int grid[][] = new int[8][7];//储存游戏按钮位置
static boolean pressInformation=false; //判断是否有按钮被选中
int x0=0,y0=0,x=0,y=0,fristMsg=0,secondMsg=0,validateLV; //游戏按钮的位置坐标
int i,j,k,n;//消除方法控制
public void init(){
mainFrame=new JFrame("JKJ连连看");
thisContainer = mainFrame.getContentPane();
thisContainer.setLayout(new BorderLayout());
centerPanel=new JPanel();
southPanel=new JPanel();
northPanel=new JPanel();
thisContainer.add(centerPanel,"Center");
thisContainer.add(southPanel,"South");
thisContainer.add(northPanel,"North");
centerPanel.setLayout(new GridLayout(6,5));
for(int cols = 0;cols 6;cols++){
for(int rows = 0;rows 5;rows++ ){
diamondsButton[cols][rows]=new JButton(String.valueOf(grid[cols+1][rows+1]));
diamondsButton[cols][rows].addActionListener(this);
centerPanel.add(diamondsButton[cols][rows]);
}
}
exitButton=new JButton("退出");
exitButton.addActionListener(this);
resetButton=new JButton("重列");
resetButton.addActionListener(this);
newlyButton=new JButton("再来一局");
newlyButton.addActionListener(this);
southPanel.add(exitButton);
southPanel.add(resetButton);
southPanel.add(newlyButton);
fractionLable.setText(String.valueOf(Integer.parseInt(fractionLable.getText())));
northPanel.add(fractionLable);
mainFrame.setBounds(280,100,500,450);
mainFrame.setVisible(true);
}
public void randomBuild() {
int randoms,cols,rows;
for(int twins=1;twins=15;twins++) {
randoms=(int)(Math.random()*25+1);
for(int alike=1;alike=2;alike++) {
cols=(int)(Math.random()*6+1);
rows=(int)(Math.random()*5+1);
while(grid[cols][rows]!=0) {
cols=(int)(Math.random()*6+1);
rows=(int)(Math.random()*5+1);
}
this.grid[cols][rows]=randoms;
}
}
}
public void fraction(){
fractionLable.setText(String.valueOf(Integer.parseInt(fractionLable.getText())+100));
}
public void reload() {
int save[] = new int[30];
int n=0,cols,rows;
int grid[][]= new int[8][7];
for(int i=0;i=6;i++) {
for(int j=0;j=5;j++) {
if(this.grid[i][j]!=0) {
save[n]=this.grid[i][j];
n++;
}
}
}
n=n-1;
this.grid=grid;
while(n=0) {
cols=(int)(Math.random()*6+1);
rows=(int)(Math.random()*5+1);
while(grid[cols][rows]!=0) {
cols=(int)(Math.random()*6+1);
rows=(int)(Math.random()*5+1);
}
this.grid[cols][rows]=save[n];
n--;
}
mainFrame.setVisible(false);
pressInformation=false; //这里一定要将按钮点击信息归为初始
init();
for(int i = 0;i 6;i++){
for(int j = 0;j 5;j++ ){
if(grid[i+1][j+1]==0)
diamondsButton[i][j].setVisible(false);
}
}
}
public void estimateEven(int placeX,int placeY,JButton bz) {
if(pressInformation==false) {
x=placeX;
y=placeY;
secondMsg=grid[x][y];
secondButton=bz;
pressInformation=true;
}
else {
x0=x;
y0=y;
fristMsg=secondMsg;
firstButton=secondButton;
x=placeX;
y=placeY;
secondMsg=grid[x][y];
secondButton=bz;
if(fristMsg==secondMsg secondButton!=firstButton){
xiao();
}
}
}
public void xiao() { //相同的情况下能不能消去。仔细分析，不一条条注释
if((x0==x (y0==y+1||y0==y-1)) || ((x0==x+1||x0==x-1)(y0==y))){ //判断是否相邻
remove();
}
else{
for (j=0;j7;j++ ) {
if (grid[x0][j]==0){ //判断第一个按钮同行哪个按钮为空
if (yj) { //如果第二个按钮的Y坐标大于空按钮的Y坐标说明第一按钮在第二按钮左边
for (i=y-1;i=j;i-- ){ //判断第二按钮左侧直到第一按钮中间有没有按钮
if (grid[x][i]!=0) {
k=0;
break;
}
else //K=1说明通过了第一次验证
}
if (k==1) {
linePassOne();
}
}
if (yj){ //如果第二个按钮的Y坐标小于空按钮的Y坐标说明第一按钮在第二按钮右边
for (i=y+1;i=j ;i++ ){ //判断第二按钮左侧直到第一按钮中间有没有按钮
if (grid[x][i]!=0){
k=0;
break;
}
else
}
if (k==1){
linePassOne();
}
}
if (y==j ) {
linePassOne();
}
}
if (k==2) {
if (x0==x) {
remove();
}
if (x0x) {
for (n=x0;n=x-1;n++ ) {
if (grid[n][j]!=0) {
k=0;
break;
}
if(grid[n][j]==0 n==x-1) {
remove();
}
}
}
if (x0x) {
for (n=x0;n=x+1 ;n-- ) {
if (grid[n][j]!=0) {
k=0;
break;
}
if(grid[n][j]==0 n==x+1) {
remove();
}
}
}
}
}
for (i=0;i8;i++ ) { //列
if (grid[i][y0]==0) {
if (xi) {
for (j=x-1;j=i ;j-- ) {
if (grid[j][y]!=0) {
k=0;
break;
}
else
}
if (k==1) {
rowPassOne();
}
}
if (xi) {
for (j=x+1;j=i;j++ ) {
if (grid[j][y]!=0) {
k=0;
break;
}
else
}
if (k==1) {
rowPassOne();
}
}
if (x==i) {
rowPassOne();
}
}
if (k==2){
if (y0==y) {
remove();
}
if (y0y) {
for (n=y0;n=y-1 ;n++ ) {
if (grid[i][n]!=0) {
k=0;
break;
}
if(grid[i][n]==0 n==y-1) {
remove();
}
}
}
if (y0y) {
for (n=y0;n=y+1 ;n--) {
if (grid[i][n]!=0) {
k=0;
break;
}
if(grid[i][n]==0 n==y+1) {
remove();
}
}
}
}
}
}
}
public void linePassOne(){
if (y0j){ //第一按钮同行空按钮在左边
for (i=y0-1;i=j ;i-- ){ //判断第一按钮同左侧空按钮之间有没按钮
if (grid[x0][i]!=0) {
k=0;
break;
}
else //K=2说明通过了第二次验证
}
}
if (y0j){ //第一按钮同行空按钮在与第二按钮之间
for (i=y0+1;i=j ;i++){
if (grid[x0][i]!=0) {
k=0;
break;
}
else
}
}
}
public void rowPassOne(){
if (x0i) {
for (j=x0-1;j=i ;j-- ) {
if (grid[j][y0]!=0) {
k=0;
break;
}
else
}
}
if (x0i) {
for (j=x0+1;j=i ;j++ ) {
if (grid[j][y0]!=0) {
k=0;
break;
}
else
}
}
}
public void remove(){
firstButton.setVisible(false);
secondButton.setVisible(false);
fraction();
pressInformation=false;
k=0;
grid[x0][y0]=0;
grid[x][y]=0;
}
public void actionPerformed(ActionEvent e) {
if(e.getSource()==newlyButton){
int grid[][] = new int[8][7];
this.grid = grid;
randomBuild();
mainFrame.setVisible(false);
pressInformation=false;
init();
}
if(e.getSource()==exitButton)
System.exit(0);
if(e.getSource()==resetButton)
reload();
for(int cols = 0;cols 6;cols++){
for(int rows = 0;rows 5;rows++ ){
if(e.getSource()==diamondsButton[cols][rows])
estimateEven(cols+1,rows+1,diamondsButton[cols][rows]);
}
}
}
public static void main(String[] args) {
lianliankan llk = new lianliankan();
llk.randomBuild();
llk.init();
}
}
//old 998 lines
//new 318 lines
java多线程开发时，常常用到线程池技术，这篇文章是对创建java线程池时的七个参数的详细解释。从源码中可以看出，线程池的构造函数有7个参数，分别是corePoolSize、maximumPoolSize、keepAliveTime、unit、workQueue、threadFactory、handler。下面会对这7个参数一一解释。
线程池中会维护一个最小的线程数量，即使这些线程处理空闲状态，他们也不会 被销毁，除非设置了allowCoreThreadTimeOut。这里的最小线程数量即是corePoolSize。
一个任务被提交到线程池后，首先会缓存到工作队列（后面会介绍）中，如果工作队列满了，则会创建一个新线程，然后从工作队列中的取出一个任务交由新线程来处理，而将刚提交的任务放入工作队列。线程池不会无限制的去创建新线程，它会有一个最大线程数量的限制，这个数量即由maximunPoolSize来指定。
一个线程如果处于空闲状态，并且当前的线程数量大于corePoolSize，那么在指定时间后，这个空闲线程会被销毁，这里的指定时间由keepAliveTime来设定。
keepAliveTime的计量单位
新任务被提交后，会先进入到此工作队列中，任务调度时再从队列中取出任务。jdk中提供了四种工作队列：
基于数组的有界阻塞队列，按FIFO排序。新任务进来后，会放到该队列的队尾，有界的数组可以防止资源耗尽问题。当线程池中线程数量达到corePoolSize后，再有新任务进来，则会将任务放入该队列的队尾，等待被调度。如果队列已经是满的，则创建一个新线程，如果线程数量已经达到maxPoolSize，则会执行拒绝策略。
基于链表的无界阻塞队列（其实最大容量为Interger.MAX），按照FIFO排序。由于该队列的近似无界性，当线程池中线程数量达到corePoolSize后，再有新任务进来，会一直存入该队列，而不会去创建新线程直到maxPoolSize，因此使用该工作队列时，参数maxPoolSize其实是不起作用的。
一个不缓存任务的阻塞队列，生产者放入一个任务必须等到消费者取出这个任务。也就是说新任务进来时，不会缓存，而是直接被调度执行该任务，如果没有可用线程，则创建新线程，如果线程数量达到maxPoolSize，则执行拒绝策略。
具有优先级的无界阻塞队列，优先级通过参数Comparator实现。
创建一个新线程时使用的工厂，可以用来设定线程名、是否为daemon线程等等
当工作队列中的任务已到达最大限制，并且线程池中的线程数量也达到最大限制，这时如果有新任务提交进来，该如何处理呢。这里的拒绝策略，就是解决这个问题的，jdk中提供了4中拒绝策略：
该策略下，在 调用者线程 中直接执行该被拒绝任务的run方法，除非线程池已经shutdown，则直接抛弃任务。
该策略下，直接丢弃任务，并抛出RejectedExecutionException异常。
该策略下，直接丢弃任务，什么都不做。
该策略下，抛弃进入队列最早的那个任务，然后尝试把这次拒绝的任务放入队列
到此，构造线程池时的七个参数，就全部介绍完毕了。
上面 wuzhikun12同学写的不错，但我想还不能运行，并且还不太完善。我给个能运行的：（注意：文件名为：Test.java)
//要实现对象间的比较，就必须实现Comparable接口，它里面有个compareTo方法
//Comparable最好使用泛型，这样，无论是速度还是代码量都会减少
@SuppressWarnings("unchecked")
class Student implements ComparableStudent{
private String studentNo; //学号
private String studentName; //姓名
private double englishScore; //英语成绩
private double computerScore; //计算机成绩
private double mathScore; //数学成绩
private double totalScore; //总成绩
//空构造函数
public Student() {}
//构造函数
public Student(String studentNo,String studentName,double englishSocre,double computerScore,double mathScore) {
this.studentNo = studentNo;
this.studentName = studentName;
this.englishScore = englishSocre;
this.computerScore = computerScore;
this.mathScore = mathScore;
}
//计算总成绩
public double sum() {
this.totalScore = englishScore+computerScore+mathScore;
return totalScore;
}
//计算评测成绩
public double testScore() {
return sum()/3;
}
//实现compareTO方法
@Override
public int compareTo(Student student) {
double studentTotal = student.getTotalScore();
return totalScore==studentTotal?0:(totalScorestudentTotal?1:-1);
}
//重写toString方法
public String toString(){
return "学号："+this.getStudentNo()+" 姓名："+this.getStudentName()+" 英语成绩："+this.getEnglishScore()+" 数学成绩："+this.getMathScore()+" 计算机成绩："+this.getComputerScore()+" 总成绩："+this.getTotalScore();
}
//重写equals方法
public boolean equals(Object obj) {
if(obj == null){
return false;
}
if(!(obj instanceof Student)){
return false;
}
Student student = (Student)obj;
if(this.studentNo.equals(student.getStudentName())) { //照现实来说，比较是不是同一个学生，应该只是看他的学号是不是相同
return true;
} else {
return false;
}
}
/*以下为get和set方法，我个人认为，totalScore的set的方法没必要要，因为它是由其它成绩计算出来的
在set方法中，没设置一次值，调用一次sum方法，即重新计算总成绩
*/
public String getStudentNo() {
return studentNo;
}
public void setStudentNo(String studentNo) {
this.studentNo = studentNo;
sum();
}
public String getStudentName() {
return studentName;
}
public void setStudentName(String studentName) {
this.studentName = studentName;
sum();
}
public double getEnglishScore() {
return englishScore;
}
public void setEnglishScore(double englishScore) {
this.englishScore = englishScore;
sum();
}
public double getComputerScore() {
return computerScore;
}
public void setComputerScore(double computerScore) {
this.computerScore = computerScore;
sum();
}
public double getMathScore() {
return mathScore;
}
public void setMathScore(double mathScore) {
this.mathScore = mathScore;
sum();
}
public double getTotalScore() {
return totalScore;
}
}
//Student子类学习委员类的实现
class StudentXW extends Student {
//重写父类Student的testScore()方法
@Override
public double testScore() {
return sum()/3+3;
}
public StudentXW() {}
//StudentXW的构造函数
public StudentXW(String studentNo,String studentName,double englishSocre,double computerScore,double mathScore) {
super(studentNo,studentName,englishSocre,computerScore,mathScore);
}
}
//Student子类班长类的实现
class StudentBZ extends Student {
//重写父类Student的testScore()方法
@Override
public double testScore() {
return sum()/3+5;
}
public StudentBZ() {}
//StudentXW的构造函数
public StudentBZ(String studentNo,String studentName,double englishSocre,double computerScore,double mathScore) {
super(studentNo,studentName,englishSocre,computerScore,mathScore);
}
}
//测试类
public class Test {
public static void main(String[] args) {
//生成若干个student类、StudentXW类、StudentBZ类
Student student1 = new Student("s001","张三",70.5,50,88.5);
Student student2 = new Student("s002","李四",88,65,88.5);
Student student3 = new Student("s003","王五",67,77,90);
StudentXW student4 = new StudentXW("s004","李六",99,88,99.5);
StudentBZ student5 = new StudentBZ("s005","朱漆",56,65.6,43.5);
Student[] students = {student1,student2,student3,student4,student5};
for(int i = 0 ; istudents.length; i++){
double avgScore = students[i].testScore();
System.out.println(students[i].getStudentName()+"学生的评测成绩为："+ avgScore+"分");
}
}
}
运行结果为：
张三学生的评测成绩为：69.66666666666667分
李四学生的评测成绩为：80.5分
王五学生的评测成绩为：78.0分
李六学生的评测成绩为：98.5分
朱漆学生的评测成绩为：60.03333333333333分
package com.regex;
import java.io.*;
import java.net.URLDecoder;
import java.util.regex.*;
public class Regex {
private int REMARK=0;
private int LOGIC=0;
private int PHYSIC=0;
boolean start=false;
/**
* @param args
*/
public static void main(String[] args) { //测试方法
// TODO Auto-generated method stub
Regex re=new Regex();
re.regCount("Regex.java");
System.out.println("remark Line: "+re.REMARK);
System.out.println("logic Line: "+re.LOGIC);
System.out.println("physic Line: "+re.PHYSIC);
}/**
* @author BlueDance
* @param s
* @deprecated count
*/
public void regCount(String s){
String url=null;
try {
url=URLDecoder.decode(this.getClass().getResource(s).getPath(),"UTF-8");
} catch (Exception e) {
e.printStackTrace();
// TODO: handle exception
}
try {
BufferedReader br=new BufferedReader(new FileReader(new File(url)));
String s1=null;
while((s1=br.readLine())!=null){
PHYSIC++;
if(CheckChar(s1)==1){
REMARK++;
System.out.println("纯注释行："+s1);
}
if(CheckChar(s1)==2){
LOGIC++;
REMARK++;
System.out.println("非纯注释行："+s1);
}
if(CheckChar(s1)==3)
LOGIC++;
}
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}catch(IOException e){
e.printStackTrace();
}
}
/**
*
* @param s
* @return int
* @version check s
*/
public int CheckChar(String s){
String s1=null;
if(s!=null)
s1=s.trim();
//System.out.println(regCheck(s1,re));
if(regCheck(s1,"(//.*)")) //判断//开头的为纯注释行
return 1;
if(regCheck(s1,"(.*[;{})] *//.*)")) //判断不是//开头的非纯注释行
return 2;
if(regCheck(s1,"(//*.*)")){ //判断/*开头的纯注释行
start=true;
return 1;
}
if(regCheck(s1,"(.*[;{})]//*.*)")){ //判断不是/*开头的非纯注释行
start=true;
return 2;
}
if(regCheck(s1,"(.* */*/)")){ //判断*/结尾的纯注释行
start=false;
return 1;
}
if(regCheck(s1,"(.* */*/.*)")!strCheck(s1)){ //判断不是*/结尾的非纯注释行
if(strCheck(s1)){
start=false;
return 2;
}
}
if(start==true) //状态代码，start即/*开始时start=true*/结束时为false
return 1;
return 3;//ssssllll
}//aeee
/**
*
* @param s
* @param re
* @return boolean
*/
public boolean regCheck(String s,String re){ //正则表达试判断方法
return Pattern.matches(re,s);
}
public boolean strCheck(String s){ //中间有*/的字符判断 此方法最关键
if(s.indexOf("*/")0){
int count=0;
String y[]=s.split("/*/");
boolean boo[]=new boolean[y.length];
for (int i = 0; i y.length-1; i++) {
char c[]=y[i].toCharArray();
for (int j = 0; j c.length; j++) {
if(c[j]=='\\'c[j+1]=='"'){
count++;
}
}
if(count%2==0){
if(countNumber("\"",y[i])%2!=0){
boo[i]=true;
}else{
boo[i]=false;
}
}else{
if(countNumber("\"",y[i])%2==0){
boo[i]=true;
}else{
boo[i]=false;
}
}
}
for(int i=0;iboo.length;i++){
if(!boo[i])
return false;
}
return true;
}
return false;
}
public int countNumber(String s,String y){ //此方法为我前面写的字符串出现次数统计方法,不懂的可以看我前面的文章
int count=0;
String [] k=y.split(s);
if(y.lastIndexOf(s)==(y.length()-s.length()))
count=k.length;
else
count=k.length-1;
if(count==0)
System.out.println ("字符串\""+s+"\"在字符串\""+y+"\"没有出现过");
else
return count;
return -1;
}
}
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class GoodLucky extends JFrame implements ActionListener{
JTextField tf = new JTextField(); //实例化一个文本域
//设置两个按钮
JButton b1 = new JButton("开始");
JButton b2 = new JButton("停止");
boolean isGo = false;
//构造函数
public GoodLucky(){
b1.setActionCommand("start");//在开始按钮上设置一个动作监听 start
JPanel p = new JPanel(); //实例化一个可视化容器
//将两个按钮添加到可视化容器上面，用add方法
p.add(b1);
p.add(b2);
//在两个按钮上增加监听的属性,自动调用下面的监听处理方法actionPerformed(ActionEvent e)，如果要代码有更好的可读性，可用内部类实现动作
//监听处理。
b1.addActionListener(this);
b2.addActionListener(this);
//将停止按钮设置为不可编辑（即不可按的状态）
b2.setEnabled(false);
this.getContentPane().add(tf,"North"); //将上面的文本域放在面板的北方，也就是上面（上北下南左西右东）
this.getContentPane().add(p,"South"); //将可视化容器pannel放在南边，也就是下面
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); //设置用户在此窗体上发起 "close" 时默认执行的操作，参数EXIT_ON_CLOSE是使用 System exit 方法退出应用程序。仅在应用程序中使用
this.setSize(300,200); //设置面板大小，宽和高
this.setLocation(300,300); //设置面板刚开始的出现的位置
Cursor cu = new Cursor(Cursor.HAND_CURSOR); //用指定名称创建一个新的定制光标对象，参数表示手状光标类型
this.setCursor(cu); //为指定的光标设置光标图像，即设置光标图像为上面所创建的手状光标类型
this.setVisible(true); //将面板可视化设置为true，即可视，如果为false，即程序运行时面板会隐藏
tf.setText("welcome you! "); //设置面板的标题为欢迎
this.go(); //调用go方法
}
public void go(){
while(true){ //这里是死循环，也就是说用户不点击停止按钮的话他一直循环出现随机数，直到用户点击停止按钮循环才能推出，具体流程在actionPerformed方法中控制。
if(isGo == true){ //上面所定义的isGo的初始值为false，所以程序第一次到此会跳过
String s = ""; //设置空字符串
for(int j = 1; j = 7;j++){ //产生7个随机数
int i = (int)(Math.random() * 36) + 1;//每个随机数产生方式，这里定义灵活，可以自由定义随机数产生的方式
if(i 10){
s = s + " 0" + i; //如果产生的随机数小于10的话做处理：这里就牵扯到一个重要的概念，简单叙述一下：
/*
当一个字符串与一个整型数项相加的意思是连接，上面的s = s + " 0" + i的意思是字符串s链接0再连接整型i值，而不会导致0和整型的i相加，
产生的效果为s0i,由于s为空字符串（上面定义过的），所以当i小于零时，在个位数前面加上0，比如产生的随机数i为7的话，显示效果为 07.
*/
}else{
s = s + " " + i; //如果产生的随机数比10打的话，那么加上空格显示，即数字和数字之间有个空格
}
//以上循环循环七次，以保证能出现7个随机数
}
tf.setText(s); //将产生的随机数全部显示在文本域上，用文本域对象tf调用它的设置文本的方法setText(String)实现。
}
//以下为线程延迟
try{
Thread.sleep(10); //线程类同步方法sleep，睡眠方法，括号里的单位为ms。
}catch(java.lang.InterruptedException e){
e.printStackTrace(); //异常捕获，不用多说。
}
}
}
//以下是上面设置的事件监听的具体处理办法，即监听时间处理方法，自动调用
public void actionPerformed(ActionEvent e){ //传入一个动作事件的参数e
String s = e.getActionCommand(); //设置字符串s来存储获得动作监听，上面的start
/*
以下这个条件语句块的作用为：用户点击开始后（捕获start，用方法getActionCommand()），将命令触发设置为true，从而执行上面的go方法中的循环体（因为循环体中要求isGo参数为true,而初始为false）。
执行循环快产生随机数，并将开始按钮不可编辑化，而用户只可以使用停止按钮去停止。如果用户按下停止时，也就是没有传入参数“start”的时候，
执行else语句块中的语句，isGo设置为false，将不执行上面go中的循环语句块，从而停止产生随机数，并显示，并且把开始按钮设置为可用，而把
停止按钮设置为不可用，等待用户按下开始再去开始新一轮循环产生随机数。
*/
if(s.equals("start")){ //如果捕获到start，也就是用户触发了动作监听器，那么下面处理
isGo = true; //设置isGo为true
b1.setEnabled(false); //将开始按钮设置为不可用
b2.setEnabled(true); //将停止按钮设置为可用
}else{
isGo = false; //将isGo设置为false，isGo为循环标志位
b2.setEnabled(false); //设置停止按钮为不可用（注意看是b2,b2是停止按钮）
b1.setEnabled(true); //设置开始按钮为可用
}
}
public static void main(String[] args){
new GoodLucky(); //产生类的实例，执行方法
}
}
我来回答，Javascript是一种由Netscape的LiveScript发展而来的脚本语言，主要目的是为了解决服务器终端语言，比如Perl，遗留的速度问题。当时服务端需要对数据进行验证，由于网络速度相当缓慢，只有28.8kbps，验证步骤浪费的时间太多。于是Netscape的浏览器Navigator加入了Javascript，提供了数据验证的基本功能。
历史
在1992年，Nombas开始开发一种嵌入式脚本语言，叫做C-minus-minus(Cmm)。[待续...
能够具有交互性，能够包含更多活跃的元素，就有必要在网页中嵌入其它的技术。如：Javascript、VBScript、Document Object Model（文件目标模块）、Layers和 Cascading Style Sheets（CSS），这里主要讲Javascript。那么Javascript是什么东东？Javascript就是适应动态网页制作的需要而诞生的一种新的编程语言，如今越来越广泛地使用于Internet网页制作上。 Javascript是由 Netscape公司开发的一种脚本语言（scripting language），或者称为描述语言。在HTML基础上，使用Javascript可以开发交互式Web网页。Javascript的出现使得网页和用户之间实现了一种实时性的、动态的、交互性的关系，使网页包含更多活跃的元素和更加精彩的内容。 运行用Javascript编写的程序需要能支持Javascript语言的浏览器。Netscape公司 Navigator 3．0以上版本的浏览器都能支持 Javascript程序，微软公司 Internet Explorer 3．0以上版本的浏览器基本上支持Javascript。微软公司还有自己开发的Javascript，称为JScript。 Javascript和Jscript基本上是相同的，只是在一些细节上有出入。 Javascript短小精悍， 又是在客户机上执行的，大大提高了网页的浏览速度和交互能力。 同时它又是专门为制作Web网页而量身定做的一种简单的编程语言。
虽然，在Dreamweaver的Behaviors可以为我们方便地使用Javascript程序而不用编写代码，但我们自己了解了Javascript的编程方法后，将能更加方便灵活地应用，也使Javascript的代码更简练。本专题通过对一系列典型程序的剖析，使你快速地掌握Javascript的编程技巧，设计出质量上乘的动态网页打下坚实的基础。在此之前，我们先了解一些Javascript 的基本概念。
JavaScript 有什么特点
JavaScript 使网页增加互动性。JavaScript 使有规律地重复的HTML文段简化，减少下载时间。JavaScript 能及时响应用户的操作，对提交表单做即时的检查，无需浪费时间交由 CGI 验证。JavaScript 的特点是无穷无尽的，只要你有创意。
Java 与 JavaScript 有什么不同
很多人看到 Java 和 JavaScript 都有“Java”四个字，就以为它们是同一样东西，连我自己当初也是这样。其实它们是完完全全不同的两种东西。Java，全称应该是 Java Applet，是嵌在网页中，而又有自己独立的运行窗口的小程序。Java Applet 是预先编译好的，一个 Applet 文件（.class）用 Notepad 打开阅读，根本不能理解。Java Applet 的功能很强大，可以访问 http、ftp等协议，甚至可以在电脑上种病毒（已有先例了）。相比之下，JavaScript 的能力就比较小了。JavaScript 是一种“脚本”（“Script”），它直接把代码写到 HTML 文档中，浏览器读取它们的时候才进行编译、执行，所以能查看 HTML 源文件就能查看JavaScript 源代码。JavaScript 没有独立的运行窗口，浏览器当前窗口就是它的运行窗口。它们的相同点，我想只有同是以 Java 作编程语言一点了。
开发 JavaScript 该用什么软件
一个 JavaScript 程序其实是一个文档，一个文本文件。它是嵌入到 HTML 文档中的。所以，任何可以编写 HTML 文档的软件都可以用来开发 JavaScript。在此我推荐大家用 FrontPage 2000 附带的 Microsoft 脚本编辑器（在 FrontPage 菜单 | 工具 | 宏 | Microsoft 脚本编辑器）。它是个像 Visual Basic / C++ 一样的程序开发器，能对正在输入的语句作出简要提示。配合 FrontPage 2000，使工作量大大减少。
一、Javascript在网页的用法
Javascript加入网页有两种方法：
1、直接加入HTML文档
这是最常用的方法，大部分含有Javascript的网页都采用这种方法，如：
script language="Javascript"
!--
document.writeln("这是Javascript！采用直接插入的方法！");
//-Javascript结束--
/script
在这个例子中，我们可看到一个新的标签： script……/script，而script language="Javascript” 用来告诉浏览器这是用Javascript编写的程序，需要调动相应的解释程序进行解释。
HTML的注释标签!--和--：用来去掉浏览器所不能识别的Javascript源代码的，这对不支持 Javascript 语言的浏览器来说是很有用的。
//-Javascript结束：双斜杠表示 Javascript的注释部分，即从//开始到行尾的字符都被忽略。 至于程序中所用到的document．write（）函数则表示将括号中的文字输出到窗口中去， 这在后面将会详细介绍。 另外一点需要注意的是，script……/script的位置并不是固定的，可以包含在head....../head 或body...../body中的任何地方。
2、引用方式 如果已经存在一个Javascript源文件（以js为扩展名），则可以采用这种引用的方式，以提高程序代码的利用率。其基本格式如下：
script src＝url language="Javascript"/script
其中的Url就是程序文件的地址。同样的，这样的语句可以放在HTML文档头部或主体的任何部分。 如果要实现“直接插入方式”中所举例子的效果，可以首先创建一个Javascript源代码文件“Script.js”，其内容如下：
document.writeln("这是Javascript！采用直接插入的方法！");
在网页中可以这样调用程序：script src＝"Script.js" language="Javascript"/script 。
二、Javascript基本概念
在这里只作简单介绍，在以后的例子中结程序再作具体解释其作用。
1、运算符
运算符就是完成操和的一系列符号，它有七类：
赋值运算符、算术运算符、比较运算符、逻辑运算符、条件运算、位操作运算符和字符串运算符。
2、表达式
运算符和操作数的组合称为表达式，通常分为四类：赋值表达式、算术表达式、布尔表达式和字符串表达式。
3、语句
Javascript程序是由若干语句组成的，语句是编写程序的指令。Javascript提供了完整的基本编程语句，它们是：
赋值语句、switch选择语句、while循环语句、for循环语句、do while循环语句、break循环中止语句和continue循环中断语句。
4、函数
函数是命名的语句段，这个语句段可以被当作一个整体来引用不着和执行。使用函数要注意以下几点：
1）函数由关键字function定义；
2）函数必须先定义后使用，否则将出错；
3）函数名是调用函数时引用的名称，它对大小写是敏感的，调用函数时不可写错函数名；
4）参数表示传递给函数使用或操作的值，它可以是常量，也可以是变量；
5）return语句用于返回表达式的值，也可以没有。
5、对象
Javascript的一个重要功能就是基于对象的功能，通过基于对象的程序设计，可以用更直观、模块化和可重复使用的方式进行程序开发。
一组包含数据的属性和对属性中包含数据进行操作的方法，称为对象。比如要设定网页的背景颜色，所针对的对象就是document，所用的属性名是bgcolor，如document.bgcolor="blue"，就是表示使背景的颜色为蓝色。
6、事件
用户与网页交互时产生的操作，称为事件。绝大部分事都由用户的动作所引发，如：用户按鼠标的按钮，就产生onclick事件，若鼠标的指针的链接上移动，就产生onmouseover事件等等。在Javascript中，事件往往与事件处理程序配套使用。
学习Javascript比较快速有效的方法是先熟悉一些基本概念，然后找几个别人设计好的程序认真仔细地分析一遍，再稍作改动，再看看能否达到预期目的，不断地举一反三，既可以加深对一些参数、设计方法的理解，又可以快速地提高自己的水平。另外，再提醒一下：Javascript对大小写是敏感的，特别是一些对象、方法、属性的大小写一定要一致，要养成一种良好的习惯，否则在调试程序时可要累死你了。
7、变量
如 var myVariable = "some value"; 9415希望对你有帮助！
这个是我原来的笔记整理，送你了！
貌似有点长，删掉一些无关紧要的
第一课
HelloJava
1、Java开发工具JDK的安装
2、 JDK的命令工具
JDK的最重要命令行工具：
java： 启动JVM执行class
javac： Java编译器
jar： Java打包工具
javadoc： Java文档生成器
这些命令行必须要非常非常熟悉，对于每个参数都要很精通才行。对于这些命令的学习，JDK Documentation上有详细的文档。
二、 JDK Documentation
Documentation在JDK的下载页面也有下载连接，建议同时下载Documentation。Documentation是最最重要的编程手册，涵盖了整个Java所有方面的内容的描述。可以这样说，学习Java编程，大部分时间都是花在看这个Documentation上面的。我是随身携带的，写Java代码的时候，随时查看，须臾不离手。
四、 Java应用的运行环境
Java Learning Path（三）过程篇
学习Java的第一步是安装好JDK，写一个Hello World，? 其实JDK的学习没有那幺简单，关于JDK有两个问题是很容易一直困扰Java程序员的地方：一个是CLASSPATH的问题，其实从原理上来说，是要搞清楚JRE的ClassLoader是如何加载Class的；另一个问题是package和import问题，如何来寻找类的路径问题。把这两个问题摸索清楚了，就扫除了学习Java和使用JDK的最大障碍。推荐看一下王森的《Java深度历险》，对这两个问题进行了深入的探讨。
第二步是学习Java的语法。Java的语法是类C++的，基本上主流的编程语言不是类C，就是类C++的，没有什幺新东西，所以语法的学习，大概就是半天的时间足够了。唯一需要注意的是有几个不容易搞清楚的关键字的用法，public，protected，private，static，什幺时候用，为什幺要用，怎幺用，这可能需要有人来指点一下，我当初是完全自己琢磨出来的，花了很久的时间。不过后来我看到《Thinking in Java》这本书上面是讲了这些概念的。
第三步是学习Java的面向对象的编程语言的特性的地方。比如继承，构造器，抽象类，接口，方法的多态，重载，覆盖，Java的异常处理机制。对于一个没有面向对象语言背景的人来说，我觉得这个过程需要花很长很长时间，因为学习Java之前没有C++的经验，只有C的经验，我是大概花了一个月左右吧，才彻底把这些概念都搞清楚，把书上面的例子反复的揣摩，修改，尝试，把那几章内容反复的看过来，看过去，看了不下5遍，才彻底领悟了。不过我想如果有C++经验的话，应该一两天时间足够了。那幺在这个过程中，可以多看看《Thinking in Java》这本书，对面向对象的讲解非常透彻。可惜的是我学习的时候，并没有看到这本书，所以自己花了大量的时间，通过自己的尝试和揣摩来学会的。
第四步就是开始熟悉Java的类库。Java的基础类库其实就是JDK安装目录下面jrelibrt.jar这个包。学习基础类库就是学习rt.jar。基础类库里面的类非常非常多。据说有3000多个，我没有统计过。但是真正对于我们来说最核心的只有4个，分别是
java.lang.*;
java.io.*;
java.util.*;
java.sql.*;
这四个包的学习，每个包的学习都可以写成一本厚厚的教材，而O'reilly也确实是这样做的。我觉得如果时间比较紧，是不可能通过读四本书来学习。我觉得比较好的学习方法是这样的：
首先要通读整个package的框架，了解整个package的class，interface，exception的构成，最好是能够找到介绍整个包框架的文章。这些专门介绍包的书籍的前几章应该就是这些总体的框架内容介绍。
对包整体框架的把握并不是要熟悉每个类的用法，记住它有哪些属性，方法。想记也记不住的。而是要知道包有哪些方面的类构成的，这些类的用途是什幺，最核心的几个类分别是完成什幺功能的。我在给人培训的时候一般是一次课讲一个包，所以不可能详细的介绍每个类的用法，但是我反复强调，我给你们讲这些包的不是要告诉你们类的方法是怎幺调用的，也不要求你们记住类的方法调用，而是要你们了解，Java给我们提供了哪些类，每个类是用在什幺场合，当我遇到问题的时候，我知道哪个类，或者哪几个类的组合可以解决我的问题，That'all！，当我们具体写程序的时候，只要你知道该用哪个类来完成你的工作就足够了。编码的时候，具体的方法调用，是边写代码，边查Documentation，所有的东西都在Documentation里面，不要求你一定记住，实际你也记不住3000多个类的总共将近10万个方法调用。所以对每个包的总体框架的把握就变得极为重要。
第五步，通过上面的学习，如果学的比较扎实的话，就打好了Java的基础了，剩下要做的工作是扫清Documentation里面除了上面4个包之外的其它一些比较有用处的类。相信进展到这一步，Java的自学能力已经被培养出来了，可以到了直接学习Documentation的水平了。除了要做GUI编程之外，JDK里面其它会有用处的包是这些：
java.text.*;
java.net.*;
javax.naming.*;
这些包里面真正用的比较多的类其实很少，只有几个，所以不需要花很多时间。
第六步，Java Web 编程，Web编程的核心是HTTP协议，HTTP协议和Java无关，如果不熟悉HTTP协议的话，虽然也可以学好Servlet/JSP编程，但是达不到举一反三，一通百通的境界。所以HTTP协议的学习是必备的。如果熟悉了HTTP协议的话，又有了Java编程的良好的基础，学习Servlet/JSP简直易如反掌，我学习Servlet/JSP就用了不到一周的时间，然后就开始用JSP来做项目了。
在Servlet/JSP的学习中，重头仍然是Servlet Documentation。Servlet API最常用的类很少，花比较少的时间就可以掌握了。把这些类都看一遍，多写几个例子试试。Servlet/JSP编程本质就是在反复调用这些类来通过HTTP协议在Web Server和Brower之间交谈。另外对JSP，还需要熟悉几个常用JSP的标记，具体的写法记不住的话，临时查就是了。
此外Java Web编程学习的重点要放在Web Application的设计模式上，如何进行业务逻辑的分析，并且进行合理的设计，按照MVC设计模式的要求，运用Servlet和JSP分别完成不同的逻辑层，掌握如何在Servlet和JSP之间进行流程的控制和数据的共享，以及Web Application应该如何配置和部署。
第七步，J2EE编程
以上的学习过程如果是比较顺利的话，进行到这一步，难度又陡然提高。因为上面的知识内容都是只涉及一个方面，而像EJB，JMS，JTA等核心的J2EE规范往往是几种Java技术的综合运用的结晶，所以掌握起来难度比较大。
首先一定要学习好JNDI，JNDI是App Server定位服务器资源（EJB组件，Datasouce，JMS）查找方法，如果对JNDI不熟悉的话，EJB，JMS这些东西几乎学不下去。JNDI其实就是javax.naming.*这个包，运用起来很简单。难点在于服务器资源文件的配置。对于服务器资源文件的配置，就需要看看专门的文档规范了，比如web.xml的写法，ejb-jar.xml的写法等等。针对每种不同的App Server，还有自己的服务资源配置文件，也是需要熟悉的。
然后可以学习JTA，主要是要理解JTA对于事务的控制的方法，以及该在什幺场合使用JTA。这里可以简单的举个例子，我们知道一般情况可以对于一个数据库连接进行事务控制(conn.setAutoCommit(false),....,conn.commit())，做为一个原子操作，但是假设我的业务需求是要把对两个不同数据库的操作做为一个原子操作，你能做的到吗？这时候只能用JTA了。假设操作过程是先往A数据库插一条记录，然后删除B数据库另一个记录，我们自己写代码是控制不了把整个操作做为一个原子操作的。用JTA的话，由App Server来完成控制。
在学习EJB之前要学习对象序列化和RMI，RMI是EJB的基础。接着学习JMS和EJB，对于EJB来说，最关键是要理解EJB是如何通过RMI来实现对远端对象的调用的，以及在什幺情况下要用到EJB。
在学习完EJB，JMS这些东西之后，你可能会意识到要急不可待学习两个领域的知识，一个是UML，另一个是Design Pattern。Java企业软件的设计非常重视框架(Framework)的设计，一个好的软件框架是软件开发成功的必要条件。在这个时候，应该开始把学习的重点放在设计模式和框架的学习上，通过学习和实际的编程经验来掌握EJB的设计模式和J2EE的核心模式。
J2EE规范里面，除了EJB，JMS，JTA，Servlet/JSP，JDBC之外还有很多很多的企业技术，这里不一一进行介绍了。
另外还有一个最新领域Web Services。Web Services也完全没有任何新东西，它像是一种粘合剂，可以把不同的服务统一起来提供一个统一的调用接口，作为使用者来说，我只要获得服务提供者给我的WSDL（对服务的描述），就够了，我完全不知道服务器提供者提供的服务究竟是EJB组件，还是.Net组件，还是什幺CORBA组件，还是其它的什幺实现，我也不需要知道。Web Services最伟大的地方就在于通过统一的服务提供方式和调用方式，实现了整个Internet服务的共享，是一个非常令人激动的技术领域。Web Services好象目前还没有什幺很好的书籍，但是可以通过在网络上面查资料的方式来学习。
所以我觉得其实不是特别需要例程的，自己写的破坏例程就是最好的例子，如果你实在对自己写的代码不放心的话，我强烈推荐你看看JDK基础类库的Java源代码。在JDK安装目录下面会有一个src.zip，解开来就可以完整的看到整个JDK基础类库，也就是rt.jar的Java源代码，你可以参考一下Sun是怎幺写Java程序的，规范是什幺样子的。我自己在学习Java的类库的时候，当有些地方理解的不是很清楚的时候，或者想更加清晰的理解运作的细节的时候，往往会打开相应的类的源代码，通过看源代码，所有的问题都会一扫而空。
2、Java环境变量配置
1. 预备知识1.1安装JDK到 根据不同的操作系统，下载相应的J2SE JDK 版本 （写这篇文章时最新的JDK 为1.5 update 7）。假定我们把JDK安装到D：\JDK\1507 ，不安装public JRE.
1.2 设置path在[我的电脑]上右击，选择[属性].再选择[高级]-[环境变量]，在[系统变量]中添加一个新的变量JAVA_HOME=D：\JDK\1507，然后再编辑path变量，在原来的path前面添加[ %JAVA_HOME%\BIN； ]（方框中的文字）。这样就完成了JAVA的基本设置。（windows 98 下如何在autoexec.bat 中设置，请自己找资料）
1.3 演示程序
为了帮助理解，我写了一个JavaBootTest.java 的小程序来显示。
public class JavaBootTest {
public static void main(String[] args) {
System.out.println(" The Classpath are: ");
System.out.println(System.getProperty("java.class.path"));
//other program lines
}
}
用下面的两条命令分别编译和运行。
javac JavaBootTest.java
java JavaBootTest
2. JAVA程序运行时如何查找类文件======================================================================
根据JDK 文档说明， JAVA 程序以以下3种顺序查找运行的类文件。
1.Bootstrap classes （*）
2.Extension classes
3.Users classes
如何设置CLASSPATH，是初学者常提出的问题。网上有很多文章提到了许多如何设置的方法，但是都没有讲为什么要这样设置（令人感到悲哀的是：绝大部分的人的观点是不正确的）。
为了帮助大家更好的学习JAVA的基本知识，同时也是锻炼自己的Type水平，于是有了这篇文章的诞生。主要参考资料来自来自官方JDK文档，希望对大家有用（所说的观点针对1.4.2 and 5.0版本）。
------------------------------------------------------------------------------------------------------------------------------
1. 预备知识1.1安装JDK到 根据不同的操作系统，下载相应的J2SE JDK 版本 （写这篇文章时最新的JDK 为1.5 update 7）。假定我们把JDK安装到D：\JDK\1507 ，不安装public JRE.
1.2 设置path在[我的电脑]上右击，选择[属性].再选择[高级]-[环境变量]，在[系统变量]中添加一个新的变量JAVA_HOME=D：\JDK\1507，然后再编辑path变量，在原来的path前面添加[ %JAVA_HOME%\BIN； ]（方框中的文字）。这样就完成了JAVA的基本设置。（windows 98 下如何在autoexec.bat 中设置，请自己找资料）
1.3 演示程序
为了帮助理解，我写了一个JavaBootTest.java 的小程序来显示。
public class JavaBootTest { public static void main（String[] args） { System.out.println（" The Classpath are： "）；System.out.println（System.getProperty（"java.class.path"））；//other program lines }
用下面的两条命令分别编译和运行。
javac JavaBootTest.java java JavaBootTest
2. JAVA程序运行时如何查找类文件======================================================================根据JDK 文档说明， JAVA 程序以以下3种顺序查找运行的类文件。
1.Bootstrap classes （*）
2.Extension classes 3.Users classes
2.1 Bootstrap classes就是JAVA在启动时载入的类文件，这些类文件主要是rt.jar 和 jre/lib 目录下的一些类文件。Bootstrap过程中的class path是保存在 sun.boot.class.path 系统属性中的。可以通过System.out.println（System.getProperty（"sun.boot.class.path"））； 来显示。同时Bootstrap classes 可以通过 -Xbootclasspath 命令行参数来指定。
下面列出了系统中默认的Bootstrap classes：
* Bootstrap bootstrap是皮鞋后部的一条小带子或一个小环，它可以使你方便地把鞋子穿起来。在计算机中，是指使用一个很小的程序将某个特定的程序（通常是指操作系统）载入计算机中。
2.2 Extension classes （扩展类文件）
Extension classes 主要是指的jre/lib/ext 目录下的类文件，这些文件必须在jar 文件或 zip 文件中。如果不同名字的jar 文件包含有相同的类文件，那么哪一个类文件被载入是不确定的。
2.3 User classes （用户自定义的类文件）
现在到了最重要的地方了，我们常说的设置CLASSPATH 其实就是指定 User classes.JAVA 按照以下四种顺序查找User classes. 2.3.1. 默认的User classes . （dot） 就是指当前目录。
2.3.2. 系统变量 CLASSPATH 所指定的类库，该变量覆盖（override）默认的User classes. 2.3.3. 用命令行参数 -cp 或 -classpath指定的类库。这个时候覆盖默认的User classes 和CLASSPATH变量。
2.3.4. 通过-jar 参数指定的jar文件。此时覆盖上面的三种情况，如果使用这种情况，所有的类文件必须来自指定的jar 文件。
了解了java如何查找User classes，我们接下来将要学习如何设置 CLASSPATH变量。
3 如何正确设置CLASSPATH如果只是一般运用java，只是用到java的基本库文件，练练手而已，则不需要设置CLASSPATH .但是在一般开发情况下，这是很少遇到的。所以我们要自己设置CLASSPATH .我们一般的方法就是按照2.3.2 来设置CLASSPATH 系统变量，像开始设置path一样，我们可以添加一个CLASSPATH的系统变量。网上有些文章所提到的添加rt.jar 和 tools.jar 等等是不需要的，因为这些类库是属于Bootstrap classes的。我们只要定义User classes ，如果我们要编译servlet 那么只要servlet-api.jar 和 jsp-api.jar 就可以实现基本的需要了。
另外要注意的是2.3.2 override 2.3.1.我们设置CLASSPATH 时要将 .（dot）[表示当前目录]放在CLASSPATH中，然后用 ；（semicolon）分隔开来。由于其他提供的类文件都是放在jar文件中，我们设置时一定要将完整的jar 文件包含在CLASSPATH 中，而不是将其目录添加到CLASSPATH 中（很重要的一点，我以前就是理解错误了）。
这个时候又一个问题出现了，当需要添加的jar 文件过多时，管理java 类库变得很麻烦。所以我认为在基础学习时用命令行编译调试，有利于JAVA的学习，但是到开发时则一定要用到 IDE 工具（现在比较流行的是eclipse 和 netbeans ，还有些人喜欢 jcreator） .在eclipse 中通过 [windows][Preferences][Java][Build Path]来指定。其中有两部分Classpath Variables User Libraries.如何设置在这里就不详细说明了，自己试一下就可以了，比较简单。在新建项目时，把自己定义的变量添加到Build Path 中就可以了。
3、HelloWorld的编写
Public Welcome
{
Public Static Void main(String[] args)
{
System.out.println("Hello Java");
}
}
4、Javac Java工具的使用
5、HelloJava中存在的问题：（网络转载）
* 错误1：
'javac' 不是内部或外部命令，也不是可运行的程序或批处理文件。
(javac: Command not found)
产生的原因是没有设置好环境变量path。Win98下在autoexce.bat中加入
path=%path%;c:jdk1.2in，Win2000下则控制面板-系统-高级-环境变量-系统变
量...看到了？双击Path，在后面加上c:jdk1.2in。当然我们假设JDK安装在了
c:jdk1.2目录下（有点唐僧了？）...好像还要重启系统才起作用...(//知道了！//西
红柿)
好，再试试！javac HelloWorld
* 错误2：
HelloWorld is an invalid option or argument.
拜托，给点专业精神，java的源程序是一定要存成.java文件的，而且编译时要写全
.java呀。
OK， javac HelloWorld.java （这回总该成了吧？）
* 错误3：
HelloWorld.java:1: Public class helloworld must be defined in a file called
"HelloWorld.java".
public class helloworld{
^
这个问题嘛，是因为你的类的名字与文件的名字不一致。（谁说的，明明看到人家都有
这样写的 ;( ） OK，准确地说，一个Java源程序中可以定义多个类，但是，具有public
属性的类只能有一个，而且要与文件名相一致。还有，main方法一定要放在这个public
的类之中，这样才能java（运行）这个类。另外一点是Java语言里面是严格区分大小写
的，初学者要注意呀。像上例中 helloworld 与 HelloWorld 就认为是不一样，因而...
oh... 好，改好了，嘻嘻... javac HelloWorld.java
...（咦，怎么什么也没有呀？）//faint 这就是编译通过了！看看是不是多了一个
HelloWorld.class ?
(hehe..按书上教的:) java HelloWorld (!! 这个我知道，不是java HelloWorld.class
哟）
* 错误4：
Exception in thread "main" java.lang.NoClassDefFoundError: HelloWorld
呵呵，这个嘛，就是著名的类路径(classpath)问题啦。实际上，类路径是在编译过程就
涉及的Java中的概念。classpath就是指明去哪里找用到的类，就这么简单。由于我们的
HelloWorld没用到其它的（非java.lang包中的）类，所以编译时没遇到这个问题。运行
时呢，就要指明你的类在哪里了。解决方法嘛，可以用下面的命令运行：
java -classpath . HelloWorld
“.”就代表当前目录。当然这样做有点麻烦（是“太麻烦”！），我们可以在环境变量
中设置默认的classpath。方法就照上述设置path那样。将classpath设为：
classpath=.;c:jdk1.2libdt.jar;c:jdk1.2lib ools.jar 后面的两个建议也设上
，以后开发用的着。
java -classpath . HelloWorld（再不出来我就不学java了）
* 错误5：
Exception in thread "main" java.lang.NoSuchMethodError: main
（//咣当）别，坚持住。看看你的代码，问题出在main方法的定义上，写对地方了吗，
是这样写的吗：
public static void main(String args[]) { //一个字都不要差，先别问为什么了...
对，包括大小写！
java -classpath . HelloWorld （听天由命了！）
Hello World！
（faint!终于...）
欢迎来到Java世界！所以说，无法运行HelloWorld 真的并不是一个“最简单的问题”。
附：HelloWorld.java
// HelloWorld.java
public class HelloWorld {
public static void main(String args[]) {
System.out.println("Hello World!") ;
}
}
