大家好!

作为我对Java的自学的一部分，我正在尝试完成可用的Java初学者分配之一đây(非常古老的东西-2001)

问题是我不知道如何应对这个挑战:(我将不胜感激任何建议，因为该解决方案不再可用，仅链接到压缩存档即可。

lời chào,
玛丽

PS。分配:

**“**分配3:主题3，子类的分配

(这是对以下项目创建的项目的修订:
阿巴拉契亚州立大学CS的Cindy Norris教授)

这项作业的目的是让您在特别有用的环境中练习子类。您将为最少的机器语言-MML编写解释器。机器语言指令的一般形式是

标签说明寄存器列表

label是该行的标签。其他说明可能会“跳转”到该标签。

指令是实际的指令。在MML中，有用于加，乘等操作，用于存储和检索整数以及有条件地分支到其他标签的指令(如if语句)。

register-list是指令处理的寄存器列表。寄存器是计算机内存中的简单，整数存储区域，非常类似于变量。在MML中，有32个寄存器，编号为0、1，...，31。

MML具有以下说明:

L1添加r s1 s2 -添加寄存器s1和s2的内容，并将结果存储在寄存器r中。

L1 sub r s1 s2 -从s1的内容中减去寄存器s2的内容，并将结果存储在寄存器r中。

L1 mul s1 s2 -将寄存器s1和s2的内容相乘，并将结果存储在寄存器r中。

L1 div r s1 s2 -将寄存器s1的内容除以(寄存器s2的内容)(Java整数除法)并将结果存储在寄存器r中。

L1 out s1 -在Java控制台上打印寄存器s1的内容(使用println)。

L1 lin r x -将整数x存储在寄存器r中。

L1 bnz s1 L2 如果寄存器s1的内容不为零，则使标记为L2的语句成为下一个要执行的语句。

我们将不同指令的数量减少了，这样您的工作量就会减少。例如，可能存在其他分支指令，否定指令，输入指令等等。但是，一旦实现了这种小语言，就可以轻松添加更多说明。

L1是任何标识符，实际上是任何非空白字符序列。程序的每个语句必须用不同的标识符标记。 s1，s2和r中的每一个都是0..31范围内的整数，并且引用执行语言MML的计算机中32个寄存器之一。这是一个用于计算阶乘6的MML程序的示例。请注意，指令的相邻字段(标签，操作码和操作数)由空格分隔。

f0 lin 20 6
f1 lin 21 1
f2 lin 22 1
f3 mul 21 21 20
f4 sub 20 20 22
f5 bnz 20 f3
f6 out 21

程序的指令按顺序执行(从第一个开始)，除非通过执行bnz指令来更改顺序。当其最后一条指令已执行(并且不改变执行顺序)时，执行终止。

您的口译员会

从用户获取包含程序

的文件的名称

从文件中读取程序并将其转换为内部格式

打印程序

执行程序，然后

打印寄存器的最终值。 “

Machine.java

nhập java.util.*;

// The machine language interpreter
public class Machine {
    // The labels in the MML program, in the order in which
    // they appear (are defined) in the program
    private Labels labels= new Labels(); 

    // The MML program, consisting of prog.size() instructions, each
    // of class Instruction (or one of its subclasses)
    private Vector prog= new Vector();   

    // The registers of the MML machine
    private Registers registers;

    // The program counter; it contains the index (in prog) of
    // the next instruction to be executed.
    private int PC= 0;

    public static void main (String[] pars) {

        Machine m= new Machine();
        Translator.readAndTranslate(m.labels, m.prog);

        System.out.println("Here is the program; it has " +
      m.prog.size() + " instructions.");
        m.print();
        System.out.println();

        System.out.println("Beginning program execution.");
        m.execute();
 System.out.println("Ending program execution.");

        System.out.println("Values of registers at program termination:");
        System.out.println(m.registers + ".");
 Hệ thống. thoát(0);
    }

    // Print the program
    public void print() {
        for (int i= 0; i != prog.size(); i++) {
            System.out.println((Instruction) prog.elementAt(i));
        }
    }

    // Execute the program in prog, beginning at instruction 0.
    // Precondition: the program and its labels have been store properly.
    public void execute() {
 PC= 0;
 registers= new Registers();
 while (PC < prog.size()) {
     Instruction ins= (Instruction)prog.elementAt(PC);
     PC= PC+1;
     ins.execute(this);
 }
    }

    // = the registers of this machine
    public Registers getRegisters() {
 return registers;
    }

    // = the labels of this machine
    public Labels getLabels() {
 return labels;
    }

    // Set the program counter to pc
    public void setPC(int pc) {
 PC= pc;
    }
}

Translator.java

import java.io.*;
nhập java.util.*;
nhập javax.swing.*;

// The translator of a small program. All the fields and methods are static.
public class Translator {
    private static BufferedReader br; // Reader attached to the file chosen by the user

    // word + line is the part of the current line that's not yet processed
    // word has no whitespace
    // If word and line are not empty, line begins with whitespace
    private static String line="";    
    private static String word=""; 

    private static Labels labels; // The labels of the program being translated 
    private static Vector program; // The program to be created  

    // Obtain a file name from the user and translate the 
    // small program in that file into lab (the labels) and
    // prog (the program)
    // return "no errors were detected"
    public static boolean readAndTranslate(Labels lab, Vector prog) {
        thử {
            getReader();
        } catch(IOException ioE) {
            System.out.println("Sai: IO error to start " );
            trả về false;
        }
        labels= lab;
        labels.reset();
        program= prog;
        program.removeAllElements();

        try { line = br.readLine();
        }
        catch (IOException ioE) {
            trả về false;
        }

        // Each iteration processes line and reads the next line into line
        while (line != null) {
            // Store the label in label
     String label= scan(); 

            if (label.length() > 0) {

                Instruction ins= getInstruction(label);
                if ( ins != null ) {
                    labels.addLabel(label); 
                    program.addElement(ins);  
                }
            }

            try { line = br.readLine();
            }
            catch (IOException ioE) {
                trả về false;
            }

        }
        trả về giá trị đúng;
    }

    // line should consist of an MML instruction, with its label already
    // removed. Translate line into an instruction with label label
    // and return the instruction
    public static Instruction getInstruction(String label) {
        int s1; // Possible operands of the instruction
        int s2;
        int r;
        số nguyên x;
        String L2;

        String ins= scan();
        if (line.equals("")) return null;

        if (ins.equals("add")) {
            r= scanInt();
            s1= scanInt();
            s2= scanInt();
            return new AddInstruction(label, r, s1, s2);
        }

        // You will have to write code here for the other instructions.

        trả về giá trị null;
     }


     // Display a JFileChooser and set br to a reader for the file chosen
     private static void getReader() throws IOException {
       JFileChooser chooser = new JFileChooser("C:\\Windows\\Desktop\\compiler\\test0.txt");
       chooser.setDialogTitle("Choose the File that contains the MML program to be executed");
       chooser.showOpenDialog(null);
       br = new BufferedReader(new FileReader(chooser.getSelectedFile()));
     }

    // Return the first word of line and remove it from line.
    // If there is no word, return ""
    public static String scan() {
        line= line.trim();
        if (line.length() == 0) 
            { return ""; }
        int i= 0;
        while (i < line.length() &&
               line.charAt(i) != ' ' &&
               line.charAt(i) != '\t') {
            i= i+1;
        }
        word= line.substring(0,i);
        line= line.substring(i);
        return word;
    }

    // Return the first word of line as an integer. If there is
    // any error, return the maximum int
    public static int scanInt() {
        String word= scan();
        if (word.length() == 0)
            { return Integer.MAX_VALUE; }

        thử {
            return Integer.parseInt(word);
        } catch (NumberFormatException e) {
            return Integer.MAX_VALUE;
        }
    }
}

Labels.java

nhập java.util.*;

// An instance contains a list of Strings, called "labels",
// in the order in which they were added to the list. 
public class Labels {
    private Vector labels= new Vector();

    // Constructor: an empty list of labels
    public Labels() {
    }

    // Add label lab to this list and return its number in the list
    // (the first one added is number 0)
    // Precondition: the list has at most 49 entries
    public int addLabel(String lab) {
        labels.addElement(lab);
        return labels.size()-1;
    }

    // = the number of label lab in the list
    // (= -1 if lab is not in the list)
    public int indexOf(String lab) {

        // invariant: lab is not in labels[0..i-1]
        for (int i= 0; i != labels.size(); i++) {
            if (lab.equals((String)(labels.elementAt(i)))) {
                return i;
            }
        }   
        trả về -1;
    }

    // representation of this instance, "(label 0, label 1, ..., label (n-1))"
    công khai String toString() {
        String r= "(";
        // invariant: r contains the representation for labels[0..i-1]
        // (with the opening "(" but no closing ")")
        for (int i= 0; i != labels.size(); i++) {
            if (i == 0) {
                r= r + (String)(labels.elementAt(i));
            } khác {
                r= r + ", " + (String)(labels.elementAt(i));
            }
        }
        r= r + ")";
        return r;
    }

    // Set the number of elements in the list to 0
    công khai void reset() {
        labels.removeAllElements();
    }
}

Registers.java

// An instance contains 31 registers and methods to access
// and change them
public class Registers {
    private int registers[]= new int[31];

    // Constructor: an instance whose registers are set to 0
    public Registers() {
        for (int i= 0; i != registers.length; i++) {
            registers[i]= 0;
        }
    }

    // = the value in register i.
    // Precondition: 0 <= i < 32
    public int getRegister(int i) {
        return registers[i];
    }

    // Set register i to v.
    // Precondition: 0 <= i < 32
    public void setRegister(int i, int v) {
        registers[i]= v;
    }

    // = a representation of the registers,
    // "(reg 0, reg 1, ..., reg 31)"
    công khai String toString() {
        String r= "(" + registers[0];
        // invariant: r contains the representation for registers[0..i-1]
        // (with the opening "(" but no closing ")")
        for (int i= 1; i != registers.length; i++) {
            r= r + ", " + registers[i];
        }
        r= r + ")";
        return r;
    }
}

Instruction.java

// This class is the superclass of the classes for machine instructions
public abstract class Instruction {

    // Constructor: an instruction with label l and opcode op
    // (op must be an operation of the language)
    public Instruction(String l, String op) {
    }

    // = the representation "label: opcode" of this Instruction
    công khai String toString() {
        return "";
    }

    // Execute this instruction on machine m. 
    public abstract void execute(Machine m);
}

câu trả lời hay nhất

分配的方式，看来您应该将Instruction子类化-外汇:

public class AddInstruction implements Instruction{

    public AddInstruction(String l, int r, int s1, int s2) {
        // Store the stuff passed in
    }

    public void execute(Machine m) {
        Registers reg = m.getRegisters();
        reg.setRegister(r, reg.getRegister(s1) + reg.getRegister(s2));
    }
}

关于java - JAVA:子类，自学测试，类(class)作业，作业，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/2136712/