JAVA：子类,自学习测试,课程作业,家庭作业
内容导读
互联网集市收集整理的这篇技术教程文章主要介绍了JAVA：子类,自学习测试,课程作业,家庭作业，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含9471字，纯文字阅读大概需要14分钟。
内容图文
大家好！
作为我自学Java的一部分,我试图完成其中一个可用的Java begginer作业here(很老的东西 – 2001)
问题是我不知道如何应对这一挑战:(我将不胜感激任何建议因为解决方案不再可用,只有链接到压缩档案工作正常.
问候,
玛丽
PS.分配：
**“**作业3：主题3,子类的作业
(这是由.创建的项目的修订版
阿巴拉契亚州立大学CS的Cindy Norris教授
这项任务的目标是让你在一个特别有用的环境中练习子类.您将为最小的机器语言编写一个解释器 – MML.机器语言指令的一般形式是
标签指令寄存器列表
label是该行的标签.其他说明可能会“跳转”到该标签.
指令是实际的指令.在MML中,有添加,乘法等的指令,用于存储和检索整数,以及有条件地分支到其他标签(如if语句).
register-list是指令操作的寄存器列表.寄存器是计算机存储器中的简单,整数,存储区域,非常类似于变量.在MML中,有32个寄存器,编号为0,1,…,31.
MML有以下说明：
L1 add r s1 s2 – 添加寄存器s1和s2的内容,并将结果存储在寄存器r中.
L1 sub r s1 s2 – 从s1的内容中减去寄存器s2的内容,并将结果存储在寄存器r中.
L1 mul r 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
import 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 + ".");
System.exit(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.*;
import java.util.*;
import 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) {
try {
getReader();
} catch(IOException ioE) {
System.out.println("Sai: IO error to start " );
return false;
}
labels= lab;
labels.reset();
program= prog;
program.removeAllElements();
try { line = br.readLine();
}
catch (IOException ioE) {
return 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) {
return false;
}
}
return true;
}
// 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;
int 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.
return 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; }
try {
return Integer.parseInt(word);
} catch (NumberFormatException e) {
return Integer.MAX_VALUE;
}
}
}
Labels.java
import 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;
}
}
return -1;
}
// representation of this instance, "(label 0, label 1, ..., label (n-1))"
public 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));
} else {
r= r + ", " + (String)(labels.elementAt(i));
}
}
r= r + ")";
return r;
}
// Set the number of elements in the list to 0
public 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)"
public 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
public String toString() {
return "";
}
// Execute this instruction on machine m.
public abstract void execute(Machine m);
}
解决方法:
任务倾向的方式,似乎你应该将指令子类化 – 外汇：
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：子类,自学习测试,课程作业,家庭作业所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。
内容备注
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。
内容手机端
扫描二维码推送至手机访问。
来源：【匿名】