Eclipse 实现 Java 编辑器【二】（实现功能）

1. 实验介绍

1. 实验内容

在上次实验中我们完成了编辑器的界面，可是按钮的响应功能并未完成，在本节实验中我们将实现界面组件事件响应逻辑和 Java 文件的编辑、编译及运行。主要包括两个方法：

• public void actionPerformed(ActionEvent e)
• public void run()

2. 实验知识点

• Java Swing 编程
• IO 流操作
• Runtime 类
• Thread 的使用

3. 完整代码

这里是引用

2. 项目文件结构

3. 实验步骤

1. actionPerformed方法的实现

    public void actionPerformed(ActionEvent e)
        {
            if(e.getSource()==button_input_txt)
            {    //显示程序输入区
                mycard.show(p,"input");
            }
            else if(e.getSource()==button_compiler_text)
            {    //显示编译结果显示区
                mycard.show(p,"compiler");
            }
            else if(e.getSource()==button_see_doswin)
            {    //显示程序运行结果区
                mycard.show(p,"dos");
            }
            else if(e.getSource()==button_compiler)
            {    //如果是编译按钮，执行编译文件的方法
                if(!(compiler.isAlive()))
                {
                    compiler=new Thread(this);
                }
                try {
                    compiler.start();

                } catch (Exception e2) {
                    // TODO: handle exception
                    e2.printStackTrace();
                }

                mycard.show(p,"compiler");

            }
            else if(e.getSource()==button_run_prom)
            {    //如果是运行按钮，执行运行文件的方法
                if(!(run_prom.isAlive()))
                {
                    run_prom=new Thread(this);
                }
                try {
                    run_prom.start();
                } catch (Exception e2) {
                    // TODO: handle exception
                    e2.printStackTrace();
                }
                mycard.show(p,"dos");
            }

        }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

2. run方法的实现

然后就剩一个 run() 方法，也是最重要的一个方法。在这个方法里会判断是编译还是运行：

• 如果当前 Thread 是编译，那么会将程序输入区中的代码以.java 文件的形式保存到项目的当前目录下，并通过javac命令执行刚才保存的.java 文件生成.class 文件，编译后的信息会输出到编译结果显示区。

• 如果当前 Thread 是运行，那么会通过java命令执行编译生成的.class 文件，并将程序结果显示到程序运行结果区中。

    public void run() {
             //TODO Auto-generated method stub
            if(Thread.currentThread()==compiler)
            {
            compiler_text.setText(null);
            String temp=input_text.getText().trim();
            byte [] buffer=temp.getBytes();
            int b=buffer.length;
            String file_name=null;
       file_name=input_file_name_text.getText().trim();

      try {
    file_saved=new File(file_name);
    FileOutputStream writefile=null;
    writefile=new FileOutputStream(file_saved);
    writefile.write(buffer, 0, b);
    writefile.close();
            } catch (Exception e) {
                    // TODO: handle exception
                    System.out.println("ERROR");
                }
    try {

    //获得该进程的错误流，才可以知道运行结果到底是失败了还是成功。
     Runtime rt=Runtime.getRuntime();
       InputStream in=rt.exec("javac "+file_name).getErrorStream(); //通过Runtime调用javac命令。注意：“javac ”这个字符串是有一个空格的！！

        BufferedInputStream bufIn=new BufferedInputStream(in);

        byte[] shuzu=new byte[100];
        int n=0;
        boolean flag=true;

        //输入错误信息
    while((n=bufIn.read(shuzu, 0,shuzu.length))!=-1)
        {
            String s=null;
              s=new String(shuzu,0,n);
            compiler_text.append(s);
            if(s!=null)
                        {
                            flag=false;
                        }
            }
                    //判断是否编译成功
                    if(flag)
                    {
                        compiler_text.append("Compile Succeed!");
                    }
                } catch (Exception e) {
                    // TODO: handle exception
                }
            }
    else if(Thread.currentThread()==run_prom)
        {
            //运行文件，并将结果输出到dos_out_text

        dos_out_text.setText(null);

        try {
              Runtime rt=Runtime.getRuntime();
    String path=run_file_name_text.getText().trim();
    Process stream=rt.exec("java "+path);//调用java命令

    InputStream in=stream.getInputStream();
                    BufferedInputStream bisErr=new BufferedInputStream(stream.getErrorStream());
                    BufferedInputStream bisIn=new BufferedInputStream(in);

    byte[] buf=new byte[150];
    byte[] err_buf=new byte[150];

    @SuppressWarnings("unused")
    int m=0;
    @SuppressWarnings("unused")
    int i=0;
    String s=null;
    String err=null;

    //打印编译信息及错误信息
    while((m=bisIn.read(buf, 0, 150))!=-1)
                    {
                        s=new String(buf,0,150);
                        dos_out_text.append(s);
                    }
                                  while((i=bisErr.read(err_buf))!=-1)
                    {
                    err=new String(err_buf,0,150);
                    dos_out_text.append(err);
                    }
        }
         catch (Exception e) {
                    // TODO: handle exception
                    }
        }
     }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

3. 进行简单测试

点击按钮在程序输入区（白色），写一个简单的测试小程序吧！代码如下：

    class a
    {
        public static void main(String [] args)
        {
            System.out.println("Hello ShiYanLou");
        }
    }
1
2
3
4
5
6
7

接着在输入编译文件名(.java)后面的文本框里填入与类名相同的.java 文件，如 a.java，点击编译程序。

在输入应用程序主类名后面的文本框里填入类名，如 a，点击运行程序。

程序的运行结果将会显示在浅蓝色的文本域中。

4. 实验总结

这次实验主要涉及到了 Runtime 类和 Thread 的使用。