计组课设：实现机器数的真值还原（定点小数）、定点小数的单符号位补码加减运算、定点小数的原码一位乘法运算和浮点数的加减运算

叁歲伎倆 2024-03-31 16:02 64阅读 0赞

计算机组成原理算法实现（四）：能够实现机器数的真值还原（定点小数）、定点小数的单符号位补码加减运算、定点小数的原码一位乘法运算和浮点数的加减运算。

**目录**

系统流程图

主窗体设计

定点小数真值还原

定点小数的单符号位补码加减运算

定点小数的一位原码乘法运算

浮点数的加减运算

代码

主程序 Main.java

定点小数的真值还原 Form1.java

定点小数的单符号位补码加减运算 Form2.java

定点小数的原码一位乘法运算 Form3.java

浮点数的加减运算代码 Form4.java

--------------------

### 系统流程图 ###

![60fa162de5b8418ea31cacb8d803d2f8.png][]

### 主窗体设计 ###

菜单需要在输入口令正确后方可激活使用。由于本次课程设计所用的语言是Java，在对应主窗口的主类中设计主窗口的样式，及个对应按钮的功能，根据指导书的内容布局各个Button，本次设计主窗口共有五个按钮，其中Button1对应确认，其余的分别对四个功能按钮。除此之外，各按钮标签都已在指导书中给出，留出白色的输入口令的窗口。

![38cabdd6ffdd4cc0a883d7f14d51d89d.png][]

口令输入错误时要给出重新输入口令的提示，三次口令输入错误应该禁止使用 ![2b80b067c84846d1b6ddacd9f89df178.png][]

### **定点小数真值还原** ###

选择主窗体中“机器数的真值还原（定点小数）”时进入下图所示的窗体 ![8c1e464bf267414b900c7c683cef73cb.png][]

点击“输入”将输入焦点设置在最上面的一个文本框上或直接点击文本框，输入一个机器数（如0.1001）后，按“原->真值”、“反->真值”、“补->真值”或“移->真值”按扭中的任一个后，将在第二文本框（灰色区域）中显示对应操作的结果。选择“返回”按扭时将关闭此窗体。

一般书写所表示的数据称为真值，在计算机中为了表示符号位，通常把符号位和数字位一起编码来表示相应的数，形成了各种数据的存储和表示方法，这些编码称为机器码。常用的机器码有原码、反码、补码和移码。

a）原码：原码的数值部分是该数的绝对值，最高位表示符号位，最高位为0是正数，最高位为1是负数。

b）反码：正数的反码等于原码，负数的反码等于除符号位外其余二进制数码0变成1，1变成0。

正数： \[x\]反 = \[x\]原 = x ；负数： 符号位不变，其余变反

c）补码：正数的补码等于原码，负数的补码等于反码加1。

正数： \[x\]补= \[x\]原 ；负数： \[x\]补= \[x\]反 +1

d）移码：是符号位取反的补码，一般用做浮点数的阶码，引入的目的是为了保证浮点数的机器码为全0。

### **定点小数的单符号位补码加减运算** ###

选择主窗体中的“定点小数的单符号位补码加减运算”时进入如下图所示的窗体：操作时可直接点击在方框中输入参与运算的数据，然后再选操作按钮。当单击“加法”、“减法”第三、四个文本框显示对应的结果。选择“返回”按钮时回到主窗体。

![bacc8204df5f44e3b0e3541fd23822d7.png][]

算法的原理：

（1）参加运算操作的数都用补码表示。

（2）数据的符号与数据一样参加运算。

（3）求差时将负减数求补,用求和代替求差, 将减法运算转化为补码的加法运算。

（4）运算结果为补码。如果符号位为 0 ,表明运算结果为正；如果符号位为 1 ,则表明结果为负。（5）符号位的进位为模值，应该去掉。 补码减法 运算公式为： \[X\]补–\[Y\]补=\[X–Y\]补 (3.2) 通过 \[Y\]补 求得 \[–Y\]补 可以将减法运算转化为补码的加法运算。 已知 \[Y\]补求 \[–Y\]补 的法则是：对 \[Y\]补各位（包括符号位）取反,末位加1 ，就可以得到\[–Y\]补。

a）在定点小数机中数的表示范围是-1<x<1，如果运算过程中出现了大于1或者小于－1的情况。

b）在定点整数机（8位）中数的表示范围是-128<x<127，如果运算过程中出现了大于127或者小于－128的情况。双符号位法：将符号位扩展为2位，具体说就是对于正数两个符号位是“00”，对于负数两个符号位是“11”。两个符号位都看作数码一样参加运算。两个数相加后，其结果的符号位出现“01”或“10”两种组合时,表示发生溢出。

溢出：在定点数机器中,数的大小超出了定点数能表示的范围，叫溢出。

①符号位“01”，正溢出

②符号位“10”，负溢出

③符号位“00”或者“11”，未溢出

### **定点小数的一位原码乘法运算** ###

选择主窗体中的“定点小数的原码一位乘法运算”时进入如下图所示的窗体：

![e22e2ed88cdd4d4bb56f906810e50848.png][]

同样的，操作时点击在文本框内即可输入参与运算的数据，然后再选操作按钮。当单击“乘法”时第三个文本框显示对应的结果。选择“返回”按钮时回到主窗体。

算法的原理：在定点计算机中,两个原码表示的数相乘的运算规则是:乘积的符号位由两数的符号位按异或运算得到,而乘积的数值部分则是两个正数相乘之积。设n位被乘数和乘数用定点小数表示(定点整数也同样适用)

被乘数 \[*ｘ*\]原＝*ｘf .ｘn－1…ｘ1ｘ0*

乘数 \[*ｙ*\]原＝*ｙf .ｙn－1…ｙ1ｙ0*

则乘积 \[*ｚ*\]原＝(*ｘf*⊕*ｙf*)＋(0.*ｘn－1…ｘ1ｘ0*)(0.*ｙn－1…ｙ1ｙ0*) 式中,*ｘf*为被乘数符号,*ｙf*为乘数符号。

机器算法： 机器中一种方法是多次采用”加法－移位“的方法来完成，称为串行乘法器，它的硬件结构简单，但是速度慢，目前广泛使用的是流水式阵列乘法器，称为并行乘法器。无符号数m乘以n会产生m\*n个位积，出现m+n个列和，并行乘法器的关键是快速产生m\*n个位积，对位积进行相加运算产生m+n个列和。

第一步：位积的产生观察乘法运算0\*0＝0，0\*1＝0，1\*0＝0，1\*1＝1 相当于：a∩b 。所以m\*n个位积可以由m\*n个与门并行产生。第二步：列和的产生：利用全加器

### **浮点数的加减运算** ###

选择主窗体中的“浮点数的加减运算”时进入下图所示的窗体：先选择“输入”按钮输入参与运算的数据，再选操作按钮。当单击“加法”和“减法”时下列文本框显示对应的结果：加法的阶码和尾数、减法的阶码和尾数。选择“返回”按钮时回到主窗体。

![74140aacc6a24d858f339c4543983e46.png][]

算法的原理：浮点数的加减法运算分为六个步骤：

1）0操作数检查

浮点加减运算过程比定点运算过程复杂。如果判知两个操作数*ｘ*或*ｙ*中有一个数为0,即可得知运算结果而没有必要再进行后续的一系列操作以节省运算时间。0操作数检查步骤则用来完成这一功能。参加加法运算的数据都是非零，进入下一步。

2）比较价码大小并完成对阶

为了便于直观理解,假设两数均以补码表示,阶码采用双符号位,尾数采用单符号位。 两浮点数进行加减，首先要看两数的阶码是否相同，若二数阶码不同，表示小数点位置没有对齐，此时必须使二数阶码相同，这个过程叫作对阶。对阶操作规定使尾数右移，尾数右移后阶码作相应增加，因此对阶时,总是使小阶向大阶看齐。

3）尾数进行加减运算

对阶结束后，即可进行尾数的求和运算。不论加法运算还是减法运算，都按加法进行操作(减法利用补码减法转换成补码的加法来做)，其方法与定点加减法运算完全一样。

4）结果规格化

① 采用双符号位表示尾数时，如果两符号位为01或10时，应将结果尾数右移一位，阶码加1（叫“右规”）。

② 如果尾数最高数值位与符号位相同，应将尾数左移，阶码减１，直至数值位最高位与符号位相反（叫“左规”）。

5）舍入运算

在对阶向右规格化，尾数向右移位，这样被右移的尾数的低位部分会被丢掉，从而造成一定误差，要进行舍入处理。

简单的舍入方法有两种：一种是“0舍1入”法，即如果右移时被丢掉数位的最高位为0则舍去，为1则将尾数的末位做加加1运算。另一种是“恒置1”法，即只要数位被移掉，就在尾数的末尾恒置1。

6）判断结果是否溢出

根据补码的双符号检查溢出的方法确定阶码是否溢出。 与定点数运算不同的是，浮点数的溢出是以其运算结果的阶码的值是否产生溢出来判断的。若阶码的值超过了阶码所能表示的最大正数，则为上溢，进一步，若此时浮点数为正数，则为正上溢，记为+∞，若浮点数为负数，则为负上溢，记为-∞；若阶码的值超过了阶码所能表示的最小负数，则为下溢，进一步，若此时浮点数为正数，则为正下溢，若浮点数为负数，则为负下溢。正下溢和负下溢都作为0处理。

### **代码** ###

#### 主程序 Main.java ####

public class Main {
    	public static void main(String[] args) {
    		new Page("计算机原理课程设计");
    	}
    }

#### 主页面 Page.java ####

import java.awt.*;
    import java.awt.event.*;
    import javax.swing.JOptionPane;
    public class Page extends Frame implements ActionListener {
    	static int i = 0;
    	static int m = 1;
    	Label a1, a2, a22;
    	TextField text1;
    	Button button1, m1, m2, m3, m4;
    	Font f;
    	Page(String s) {
    		super(s); // 调用父类中的一个构造函数
    		setLayout(null);// 设置布局
    		f = new Font(" 楷体 ", Font.BOLD, 20);
    		m1 = new Button(" 机器数的真值还原（定点小数） ");
    		m2 = new Button(" 定点小数的单符号位补码加减运算 ");
    		m3 = new Button(" 定点小数的原码一位乘法运算 ");
    		m4 = new Button(" 浮点数的加减运算 ");
    		m1.addActionListener(this);
    		m2.addActionListener(this);
    		m3.addActionListener(this);
    		m4.addActionListener(this);
    		m1.setBounds(10, 30, 190, 50);
    		m2.setBounds(200, 30, 200, 50);
    		m3.setBounds(400, 30, 180,50);
    		m4.setBounds(580, 30, 120, 50);
    		add(m1);
    		add(m2);
    		add(m3);
    		add(m4);
    		a1 = new Label(" 计算机组成原理算法实现（四） ", Label.CENTER);
    		a2 = new Label(" 输入口令： ");
    		a22 = new Label(" 密码正确 ", Label.CENTER);
    		a1.setBounds(210, 110, 300, 40);
    		a1.setBackground(Color.yellow);
    		a1.setFont(f);
    		a2.setBounds(210, 200, 70, 25);
    		a2.setBackground(Color.pink);
    		a22.setBounds(260, 200, 200, 25);
    		a22.setForeground(Color.white);
    		a22.setBackground(Color.green);
    		a22.setVisible(false);
    		text1 = new TextField(18);
    		text1.setEchoChar('*');
    		text1.setBounds(310, 200, 200, 25);
    		button1 = new Button(" 确认 ");
    		button1.setBounds(320, 250, 70, 30);
    		button1.addActionListener(this);
    		add(a1);
    		add(a2);
    		add(a22);
    		add(text1);
    		add(button1);
    		setBackground(Color.white);
    		setBounds(200, 200, 710, 400);
    		setVisible(true); // 模型已构造
    		validate();
    		addWindowListener(new WindowAdapter() {
    			public void windowClosing(WindowEvent e) {
    				System.exit(0);
    			}
    		});
    	}
    
    	public void actionPerformed(ActionEvent e) {
    		String s = new String("   ");
    		if (e.getSource() == button1) {
    			while (i == 0 && m <= 3 && (!(text1.getText().equals("")))) {
    				if (text1.getText().equals(s)) {
    					i = 1;
    					JOptionPane.showMessageDialog(this, " 口令正确 ,请选择菜单栏的操作 ", "正确 ", JOptionPane.INFORMATION_MESSAGE);
    					text1.setEnabled(false);
    					text1.setVisible(false);
    					a22.setVisible(true);
    					a2.setVisible(false);
    				} else {
    					m++;
    					JOptionPane.showMessageDialog(this, " 您输入的口令不正确 ", " 警告 ", JOptionPane.WARNING_MESSAGE);
    					text1.setText(null);
    				}
    			}
    			if (m > 3) {
    				JOptionPane.showMessageDialog(this, " 您三次口令错误，确定后退出！ ", "警告 ", JOptionPane.ERROR_MESSAGE);
    				System.exit(0);
    			}
    		}
    		if (i == 1) {
    			if (e.getSource() == m1) {
    				Form1 f1 = new Form1(" 定点小数真值还原 ");
    				f1.setVisible(true);
    			} else if (e.getSource() == m2) {
    				Form2 f2 = new Form2(" 定点小数的单符号位补码加减运算 ");
    				f2.setVisible(true);
    			} else if (e.getSource() == m3) {
    				Form3 f3 = new Form3(" 定点小数的原码一位乘法运算 ");
    				f3.setVisible(true);
    			} else if (e.getSource() == m4) {
    				//Form4 f4 = new Form4();
    				Form4 f4 = new Form4(" 浮点数的加减法 ");
    				f4.setVisible(true);
    			}
    		}
    	}
    }

#### 定点小数的真值还原 Form1.java ####

import java.awt.*; 
    import java.awt.event.*; 
    import javax.swing.Box;
    import javax.swing.JOptionPane;
    public class Form1 extends Frame implements ActionListener{
    	String number,result;
    	TextField text1,text2;
    	Button re,yuan,fan,bu,yi,back; 
    	Label label;
    	Form1(String s){
    		super(s);
    		label=new Label(" 真值还原结果为： "); 
    		text1=new TextField(20);
    		text2=new TextField(20); 
    		text2.setEditable(false); 
    		re=new Button("输入");
    		yuan=new Button("原->真值"); 
    		fan=new Button("反->真值"); 
    		bu=new Button("补->真值");
    		yi=new Button("移->真值"); 
    		back=new Button("返回");
    		re.addActionListener(this); 
    		yuan.addActionListener(this); 
    		fan.addActionListener(this); 
    		bu.addActionListener(this); 
    		yi.addActionListener(this);
    		back.addActionListener(this); 
    		Panel p1,p2,p3,p4;
    		p1=new Panel(); 
    		p2=new Panel(); 
    		p3=new Panel();
    		p4=new Panel();
    		Box box=Box.createVerticalBox();
    		Label label1=new Label("机器数的真值还原（定点小数）"); 
    		label1.setFont(new Font("楷体",Font.BOLD,20)); 
    		p1.add(label1);
    		p2.add(new Label("请输入机器数：")); 
    		p2.add(text1);
    		p3.add(label); p3.add(text2); 
    		p4.add(re); p4.add(yuan);p4.add(fan);
    		p4.add(bu);p4.add(yi);p4.add(back);
    		box.add(p1);box.add(p2);box.add(p3);box.add(p4);
    		add(box); setBounds(200,200,500,300);
    		addWindowListener(new WindowAdapter(){
    			public void windowClosing(WindowEvent e){
    				setVisible(false);
    				}
    			});
    		validate();
    	}
    	
    	public void actionPerformed(ActionEvent e) {
    		if(e.getSource()==re) {
    			text1.setText(null); text2.setText(null); 
    			text1.requestFocusInWindow();
    		}
    		if(e.getSource()==yuan){     //  原->真值
    			number=text1.getText(); 
    			if(number.startsWith("0")) {
    				result=number.replaceFirst("0","+0"); 
    				text2.setText(result);
    			}
    			else if(number.startsWith("1")) {
    				result=number.replaceFirst("1","-0"); 
    				text2.setText(result);
    			}
    		}
    		if(e.getSource()==fan){       // 反->真值
    			number=text1.getText(); 
    			if(number.startsWith("0")) {
    				result=number.replaceFirst("0","+0"); 
    				text2.setText(result);
    			}
    			else if(number.startsWith("1")) {
    				char c[]=number.toCharArray(); 
    				for(int i=0;i<c.length;i++) {
    					if(c[i]=='1'){ c[i]='0';}
    					else if(c[i]=='0'){	c[i]='1';}
    				}
    				result=new String(c);
    				String s=result.replaceFirst("0","-0"); 
    				text2.setText(s);
    			}
    		}
    		if(e.getSource()==bu){
    			number=text1.getText(); 
    			if(number.startsWith("0")) {
    				result=number.replaceFirst("0","+0"); 
    				text2.setText(result);
    			}
    			else if(number.startsWith("1")) {
    				int j=number.lastIndexOf("1");
    				char a[]=number.toCharArray(); 
    				for(int i=0;i<j;i++) {
    					if(a[i]=='1'){ a[i]='0';}
    					else if(a[i]=='0'){ a[i]='1';}
    					result=new String(a);
    					String s=result.replaceFirst("0","-0");
    					text2.setText(s);
    				}
    			}
    		}
    		if(e.getSource()==yi){     // 移->真值
    			number=text1.getText(); 
    			if(number.startsWith("1")) {
    				result=number.replaceFirst("1","+0"); 
    				text2.setText(result);
    			}
    			else if(number.startsWith("0")) {
    				int j=number.lastIndexOf("1"); 
    				char a[]=number.toCharArray(); 
    				for(int i=0;i<j;i++) {
    					if(a[i]=='1'){ a[i]='0';}
    					else if(a[i]=='0'){ a[i]='1';}
    					result=new String(a);
    					String s=result.replaceFirst("1","-0"); 
    					text2.setText(s);
    				}
    			}
    		}
    		if(e.getSource()==back) {
    			text1.setText(null); 
    			text2.setText(null); 
    			setVisible(false);
    		}
    	}
    }

#### 定点小数的单符号位补码加减运算 Form2.java ####

import java.awt.*;
    import java.awt.event.*; 
    import javax.swing.Box;
    import javax.swing.JOptionPane;
    public class Form2 extends Frame implements ActionListener{
    	String num1,num2,jia,jian; 
    	char a[],b[];
    	TextField text1,text2,addResult,subResult; 
    	Button re,add,sub,back;
    	Form2(String s){
    		super(s);
    		text1=new TextField(20); 
    		text2=new TextField(20);
    		addResult=new TextField(20);
    		addResult.setEditable(false); 
    		subResult=new TextField(20);
    		subResult.setEditable(false); 
    		re=new Button("输入") ;
    		add=new Button("加法");
    		sub=new Button("减法"); 
    		back=new Button("返回"); 
    		re.addActionListener(this); 
    		add.addActionListener(this); 
    		sub.addActionListener(this); 
    		back.addActionListener(this);
    		Panel p1,p2,p3,p4,p5,p6;
    		p1=new Panel(); p2=new Panel(); p3=new Panel(); 
    		p4=new Panel(); p5=new Panel(); p6=new Panel();
    		Label label=new Label("定点小数的单符号位补码加减运算"); 
    		label.setFont(new Font("楷体",Font.BOLD,20));
    		p1.add(label);
    		p2.add(new Label("请输入第一个数:")); p2.add(text1);
    		p3.add(new Label("请输入第二个数:")); p3.add(text2);
    		p4.add(new Label("	加 法 结 果 为:")); p4.add(addResult);
    		p5.add(new Label("	减 法 结 果 为:")); p5.add(subResult);
    		p6.add(re); p6.add(add);p6.add(sub);p6.add(back);
    		Box box=Box.createVerticalBox();
    		box.add(p1);box.add(p2);box.add(p3);
    		box.add(p4);box.add(p5);box.add(p6);
    		add(box); setBounds(200,200,500,300);
    		addWindowListener(new WindowAdapter() {
    			public void windowClosing(WindowEvent e){
    				setVisible(false);
    			}
    		});
    		validate();
    	}
     
    	public void actionPerformed(ActionEvent e){
    		if(e.getSource()==re) {
    			text1.setText(null); text2.setText(null); 
    			addResult.setText(null); subResult.setText(null); 
    			text1.requestFocusInWindow();
    		}
    		if(e.getSource()==add){         //加法
    			num1=text1.getText(); 
    			num2=text2.getText();
    			char a[]=num1.toCharArray(); 
    			char b[]=num2.toCharArray(); 
    			int p=a.length;
    			char c[]=new char[p]; 
    			char d[]=new char[p];
    			for(int j=p-1;j>=0;j--){          //计算两个数的补码加
    				if(a[j]=='0' && b[j]=='0'){ 
    					c[j]='0';d[j]='0';}
    				else if(a[j]=='0'&& b[j]=='1'){ 
    					c[j]='1';d[j]='0';}
    				else if(a[j]=='1' && b[j]=='0'){ 
    					c[j]='1';d[j]='0';}
    				else if(a[j]=='1' && b[j]=='1'){
    					c[j]='0';d[j]='1';}
    				else if(a[j]=='.' && b[j] =='.'){ 
    					c[j]='.';d[j]='.';}
    				}
    			for(int k=d.length-1;k>=1;k--){
    				if(d[k]=='1' && c[k-1]=='0'){	c[k-1]='1';}
    				else if(d[k]=='1' && c[k-1]=='1'){	c[k-1]='0';d[k-1]='1';}
    				else if(d[k]=='1' && c[k-1]=='.'&& c[k-2]=='0'){ c[k-2]='1';}
    				else if(d[k]=='1' && c[k-1]=='.'&& c[k-2]=='1'){ c[k-2]='0';d[0]='1';}
    				}
    			if((d[0]=='1'&& d[2]=='1')||(d[0]=='0'&& d[2]=='0')){
    				if(c[0]=='0'){	
    					jia=new String(c);jia=jia.replaceFirst("0","+0"); 
    					addResult.setText(jia);}
    				else if(c[0]=='1'){ 
    					jia=new String(c);
    					int j=jia.lastIndexOf("1"); 
    					for(int i=0;i<j;i++){ 
    						if(c[i]=='1'){ c[i]='0';}
    						else if(c[i]=='0'){ c[i]='1';}
    						}
    					jia=new String(c);jia=jia.replaceFirst("0","-0"); 
    					addResult.setText(jia);
    					}
    			}
    			if((d[0]=='0'&& d[2]=='1')||(d[0]=='1'&& d[2]=='0')){	
    				addResult.setText("结果溢出");
    				JOptionPane.showMessageDialog(this," 加 法 结 果 溢 出 , 不 正 确 ！ "," 错 误",JOptionPane.ERROR_MESSAGE);
    			}
    		}
    		
    		if(e.getSource()==sub){
    			num1=text1.getText(); num2=text2.getText();
    			char a[]=num1.toCharArray(); char b[]=num2.toCharArray(); int m=num2.lastIndexOf("1");
    			for(int i=0;i<m;i++){ 
    				if(b[i]=='1'){ b[i]='0';}
    				else if(b[i]=='0'){ b[i]='1';}
    			}
    			int p=a.length;
    			char c[]=new char[p]; 
    			char d[]=new char[p];
    			for(int j=p-1;j>=0;j--){         //计算两个数的补码减法
    				if(a[j]=='0' && b[j]=='0'){ c[j]='0';d[j]='0';}
     				else if(a[j]=='0'&& b[j]=='1'){ c[j]='1';d[j]='0';}
    				else if(a[j]=='1' && b[j]=='0'){ c[j]='1';d[j]='0';}
    				else if(a[j]=='1' && b[j]=='1'){ c[j]='0';d[j]='1';}
    				else if(a[j]=='.' && b[j] =='.'){ c[j]='.';d[j]='.';}}
    			for(int k=d.length-1;k>=1;k--){
    				if(d[k]=='1' && c[k-1]=='0'){	c[k-1]='1';}
    				else if(d[k]=='1' && c[k-1]=='1'){	c[k-1]='0';d[k-1]='1';}
    				else if(d[k]=='1' && c[k-1]=='.'&& c[k-2]=='0'){ c[k-2]='1';}
    				else if(d[k]=='1' && c[k-1]=='.'&& c[k-2]=='1'){ c[k-2]='0';d[k-2]='1';}
    			}
    			if((d[0]=='1'&& d[2]=='1')||(d[0]=='0'&& d[2]=='0')){	
    				if(c[0]=='0') {
    					jian=new String(c); jian=jian.replaceFirst("0","+0"); 
    					subResult.setText(jian);
    				}
    				else if(c[0]=='1'){	
    					jian=new String(c);
    					int j=jian.lastIndexOf("1"); 
    					for(int i=0;i<j;i++){ 
    						if(c[i]=='1'){ c[i]='0';}
    						else if(c[i]=='0'){ c[i]='1';}
    					}
    					jian=new String(c); jian=jian.replaceFirst("0","-0"); 
    					subResult.setText(jian);
    				}
    			}
    			if((d[0]=='0'&& d[2]=='1')||(d[0]=='1'&& d[2]=='0')){	
    				subResult.setText("结果溢出");
    				JOptionPane.showMessageDialog(this," 减 法 结 果 溢 出 , 不 正 确 ！ "," 错 误",JOptionPane.ERROR_MESSAGE);
    			}
    		}
    
    		if(e.getSource()==back){
    			text1.setText(null); text2.setText(null);
    			addResult.setText(null); subResult.setText(null); 
    			setVisible(false);
    		}
    	}
    }

#### 定点小数的原码一位乘法运算 Form3.java ####

import java.awt.*; 
    import java.awt.event.*; 
    import javax.swing.Box;
    import javax.swing.JOptionPane;
    public class Form3 extends Frame implements ActionListener{
    	String s1,s2,result;
    	int me4=0;
    	static char cf='0'; 
    	Button re,mul,back;
    	String g1;
    	Font f;
    	TextField	t1,t2,t3;
    	Form3(String s){
    		super(s);
    		t1=new TextField(20); t2=new TextField(20);
    		t3=new TextField(20); t3.setEditable(false); 
    		re=new Button("输入"); 
    		mul=new Button("乘法"); 
    		back=new Button("返回"); 
    		re.addActionListener(this); 
    		mul.addActionListener(this); 
    		back.addActionListener(this); 
    		Panel p1=new Panel(),p2=new Panel(), p3=new Panel(), p4=new Panel(), p5=new Panel();
    		Label label=new Label("定点小数的原码一位乘法运算"); 
    		label.setFont(new Font("TimesRoman",Font.BOLD,24));
    		p1.add(label);
    		p2.add(new Label("请输入被乘数:")); p2.add(t1);
    		p3.add(new Label(" 请输入乘数 :")); p3.add(t2);
    		p4.add(new Label(" 乘法结果为 :")); p4.add(t3);
    		p5.add(re);
    		p5.add(mul);
    		p5.add(back);
    		Box box=Box.createVerticalBox(); 
    		box.add(p1);
    		box.add(p2);
    		box.add(p3);
    		box.add(p4);
    		box.add(p5);
    		add(box); 
    		setBounds(200,200,500,300);
    		addWindowListener(new WindowAdapter() {
    			public void windowClosing(WindowEvent e) {
    				setVisible(false);
    			}
    		});
    		validate();
    	}
     
    	//被乘数转化为原码形式
    	public String work1() {
    		String a1=t1.getText(); 
    		if(a1.startsWith("+")){
    			int index=a1.indexOf("+"); s1=a1.substring(index+1);}
    		else{
    			int index=a1.indexOf("-");
    			String ss=a1.substring(index+1); s1=ss.replaceFirst("0", "1");}
    		return s1;
    		}
    	
    	//乘数转化为原码形式
    	public String work2(){
    		String a2=t2.getText(); 
    		if(a2.startsWith("+")){
    			int index=a2.indexOf("+"); s2=a2.substring(index+1);}
    		else{
    			int index=a2.indexOf("-");
    			String ss=a2.substring(index+1); s2=ss.replaceFirst("0", "1");}
    		return	s2;
    		}
    	public String add1(char a1[],char a2[]){
    		int r=a1.length;
    		char jg[]=new char[r];
    		//char cf='0'; 
    		while(r>0){
    			if(a1[r-1]=='0'&&a2[r-1]=='0'&&cf=='0'){jg[r-1]='0';cf='0';} 
    			else if((a1[r-1]=='0'&&a2[r-1]=='0'&&cf=='1')||
    					(a1[r-1]=='0'&&a2[r-1]=='1'&&cf=='0')||
    					(a1[r-1]=='1'&&a2[r-1]=='0'&&cf=='0')){jg[r-1]='1';cf='0';}				
    			else if((a1[r-1]=='0'&&a2[r-1]=='1'&&cf=='1')||
    					(a1[r-1]=='1'&&a2[r-1]=='0'&&cf=='1')||
    					(a1[r-1]=='1'&&a2[r-1]=='1'&&cf=='0')){ jg[r-1]='0';cf='1';}
    			else if(a1[r-1]=='1'&&a2[r-1]=='1'&&cf=='1'){jg[r-1]='1';cf='1';} 	
    			else {jg[r-1]='0';}
    			r--;
    			}
    		result=new String(jg); 
    		return	result;
    	}
    	
    	//实现两数的相乘
    	public String mul(String ss1,String ss2 ){
    		char a[]=ss1.toCharArray(); 
    		char b[]=ss2.toCharArray();
    		int n1=ss1.length();
    		int n2=ss2.length();
    		char mul[]=new char[n1+n2-2];
    		int m=mul.length;
    		char temp1[]=new char[n1+n2-4];
    		char temp2[]=new char[n1+n2-4];
    		//实现积的符号位和小数点
    		if(a[0]==b[0])
    			mul[0]='0';
    		else 
    			mul[0]='1';
    		mul[1]=a[1];
    		for(int g=0;g<n1+n2-4;g++){
    			temp1[g]='0';
    		}
    		for(int g=0;g<n1+n2-4;g++){
    			temp2[g]='0';
    		}
    		//两数的绝对值部分相乘
    		for(int y=n2-1;y>=2;y--){ 
    			if(b[y]=='1') 
    				ss1.getChars(2, n1, temp2, 0); 
    			else {
    				for(int g=0;g<n1+n2-4;g++){
    					temp2[g]='0';
    				}
    			}
    			g1=add1(temp1,temp2);             //得到两个数的和
    			g1.getChars(0, g1.length(), temp1, 0);
    			for(int i=g1.length();i>=2;i--){
    				temp1[i-1]=temp1[i-2];
    			}
    			if(cf=='0') temp1[0]='0';
    			else temp1[0]='1';
    		}
    		String g2=new String(temp1); 
    		g2.getChars(0,g2.length(), mul, 2); 
    		String g3=new String(mul); 
    		return g3;
    	}
    	public void actionPerformed(ActionEvent e){
    		if(e.getSource()==re){	
    			me4=1;
    			t1.requestFocusInWindow(); 
    			t2.requestFocusInWindow(); 
    			t1.setText("");
    			t2.setText("");
    		}
    		else if(me4==1){
    			if(e.getSource()==mul){
    				String tg1=work1(); String tg2=work2(); 
    				String tg3=mul(tg1,tg2); t3.setText(tg3);
    			}
    			else if(e.getSource()==back){
    				setVisible(false);
    			}
    		}
    	}
    }

#### 浮点数的加减运算代码 Form4.java ####

import java.awt.*; 
    import java.awt.event.*; 
    import javax.swing.Box;
    import javax.swing.JOptionPane;
    public class Form4 extends Frame implements ActionListener{
    	TextField j1,t1,j2,t2,addj,addt,subj,subt;
    	Button re,add,sub,back; 
    	Form4(String s){
    		super(s);
    		j1=new TextField(15); t1=new TextField(15); 
    		j2=new TextField(15); t2=new TextField(15);
    		addj=new TextField(15);addj.setEditable(false); 
    		addt=new TextField(15);addt.setEditable(false); 
    		subj=new TextField(15);subj.setEditable(false); 
    		subt=new TextField(15);subt.setEditable(false); 
    		re=new Button("输入") ;
    		add=new Button("加法");
    		sub=new Button("减法"); 
    		back=new Button("返回"); 
    		re.addActionListener(this); 
    		add.addActionListener(this); 
    		sub.addActionListener(this); 
    		back.addActionListener(this);
    		Panel p1,p2,p3,p4,p5,p6,p7,p8,p9,p0; 
    		p1=new Panel();p2=new Panel(); p3=new Panel();p4=new Panel(); 
    		p5=new Panel();p6=new Panel();p7=new Panel();p8=new Panel(); 
    		p9=new Panel();p0=new Panel();
    		Label label=new Label("浮点数的加减运算"); 
    		label.setFont(new Font("楷体",Font.BOLD,20)); 
    		p0.add(label);
    		p1.add(new Label("第一个数的阶码:")); p1.add(j1);
    		p2.add(new Label("尾数:")); p2.add(t1);
    		p3.add(new Label("第二个数的阶码:")); p3.add(j2);
    		p4.add(new Label("尾数:")); p4.add(t2);
    		p5.add(new Label("	加 法 的 阶 码 : ")); p5.add(addj);
    		p6.add(new Label("尾数:")); p6.add(addt);
    		p7.add(new Label("	减 法 的 阶 码 : ")); p7.add(subj);
    		p8.add(new Label("尾数:")); p8.add(subt);
    		p9.add(re); p9.add(add);p9.add(sub);p9.add(back);
    		Box boxV1=Box.createVerticalBox(), boxV2=Box.createVerticalBox(), box=Box.createHorizontalBox();
    		boxV1.add(p1); boxV2.add(p2); boxV1.add(p3); boxV2.add(p4); 
    		boxV1.add(p5); boxV2.add(p6); boxV1.add(p7); boxV2.add(p8); 
    		box.add(boxV1);box.add(boxV2); 
    		add(p0,BorderLayout.NORTH); 
    		add(p9,BorderLayout.SOUTH); 
    		add(box,BorderLayout.CENTER); 
    		setBounds(200,200,500,300);
    		addWindowListener(new WindowAdapter() {
    			public void windowClosing(WindowEvent e) {
    				setVisible(false);
    			}
    		});
    		validate();
    	}
    	public void actionPerformed(ActionEvent e){
    		if(e.getSource()==re) {
    			j1.setText(null);t1.setText(null); 
    			j2.setText(null);t2.setText(null); 
    			addj.setText(null);addt.setText(null); 
    			subj.setText(null);subt.setText(null); 
    			j1.requestFocusInWindow();
    		}
    		if(e.getSource()==add){
    			String s2_=t1.getText();
    			char b1_[]=new char[s2_.length()-1]; s2_.getChars(0,2,b1_,0); 
    			s2_.getChars(3,s2_.length(),b1_,2); C.yb(b1_);
    			String s2=new String(b1_);
    			String s4_=t2.getText();;
    			char b2_[]=new char[s4_.length()-1]; s4_.getChars(0,2,b2_,0); 
    			s4_.getChars(3,s4_.length(),b2_,2); C.yb(b2_);
    			String s4=new String(b2_);
    			String s1=j1.getText();
    			char a1[]=s1.toCharArray(); C.yb(a1);
    			String s3=j2.getText();
    			char a2[]=s3.toCharArray(); C.yb(a2);
    			B.subs(a1,a2,a1);	//对阶
    			C.yb(a1);
    			int p=C.t_t(new String(a1,2,3)); 
    			char b1[]=new char[p+s2.length()];
    			for(int i=0;i<p+s2.length();i++) b1[i]='0'; 
    			char b2[]=new char[p+s4.length()]; 
    			for(int i=0;i<p+s2.length();i++) b2[i]='0'; 
    			if(a1[0]=='0'){
    				s1.getChars(0, s1.length(), a1, 0);
    				s2.getChars(0, s2.length(), b1, 0);
    				s4.getChars(0, s4.length(), b2, p);
    			}
    			else {
    				s3.getChars(0, s3.length(), a1, 0);
    				s2.getChars(0, s2.length(), b1, p);
    				s4.getChars(0, s4.length(), b2, 0);
    			}
    			B.adds(b1, b2, b1);	      //尾数相加
    			String s=new String(b1);
    			if(s.startsWith("01")||s.startsWith("10")){	        //右规
    				for(int i=b1.length-1;i>=1;i--)	b1[i]=b1[i-1]; 
    				C.addone(a1);
    			}
    			else if(s.startsWith("00")){            //左规
    				int t=s.indexOf("1")-2 ;
    				for(int i=0;i<b1.length-t;i++)
    					b1[i]=b1[i+t];	            //左移
    				for(int i=b1.length-t;i<b1.length;i++)
    					b1[i]='0';
    				String t_=Long.toBinaryString(t); 
    				char a1_[]=new char[5];
    				for(int i=0;i<5;i++)
    					a1_[i]='0'; 
    				t_.getChars(0,t_.length(),a1_,a1.length-t_.length());
    				B.subs(a1, a1_, a1);
    			}
    			else if(s.startsWith("11")){
    				int t=s.indexOf("0")-2 ;
    				for(int i=0;i<b1.length-t;i++)
    					b1[i]=b1[i+t]; 
    				for(int i=b1.length-t;i<b1.length;i++)
    					b1[i]='0'; 
    				String t_=Long.toBinaryString(t);
    				char a1_[]=new char[5];
    				for(int i=0;i<5;i++)
    					a1_[i]='0'; 
    				t_.getChars(0,t_.length(),a1_,a1.length-t_.length()); 
    				B.subs(a1, a1_, a1);
    			}
    			if(b1[b1.length-p]=='1'){               //舍入
    				String code=new String(b1,0,b1.length-p);
    				char c[]=code.toCharArray(); 
    				C.addone(c);b1=c;
    				String code_=new String(b1); 
    				if(code_.startsWith("01")||code_.startsWith("10")){    	//右规
    					for(int i=c.length-1;i>=1;i--)
    						c[i]=c[i-1]; 
    					C.addone(a1);
    				}
    			}
    	
    			if(a1[0]=='0'&&a1[1]=='1'||a1[0]=='1'&&a1[1]=='0') {
    				addj.setText("结果溢出");
    			}
    			else {
    				C.yb(a1);
    				if(a1[0]=='0') { 
    					a1[0]=' '; a1[1]=(char)('+');
    				}
    				else {
    					a1[0]=' '; a1[0]=(char)('-');
    				} 
    				String code1=new String(a1); 
    				addj.setText(code1);
    				C.yb(b1);
    				if(b1[0]=='0') { 
    					b1[1]='0'; b1[0]=(char)('+');
    				}
    				else {
    					b1[1]='0'; b1[0]=(char)('-');
    				}
    				StringBuffer code2_=new StringBuffer(new String(b1)); 
    				code2_.insert(2,".");
    				String code2=new String(code2_); 
    				addt.setText(code2);
    			}
    		}
    		if(e.getSource()==sub){
    			String s2_=t1.getText();
    			char b1_[]=new char[s2_.length()-1]; 
    			s2_.getChars(0,2,b1_,0); 
    			s2_.getChars(3,s2_.length(),b1_,2);
    			C.yb(b1_);
    			String s2=new String(b1_);
    			String s4_=t2.getText();;
    			char b2_[]=new char[s4_.length()-1]; 
    			s4_.getChars(0,2,b2_,0); 
    			s4_.getChars(3,s4_.length(),b2_,2); 
    			C.yb(b2_);
    			String s4=new String(b2_);
    			String s1=j1.getText();
    			char a1[]=s1.toCharArray(); 
    			C.yb(a1);
    			String s3=j2.getText();
    			char a2[]=s3.toCharArray(); 
    			C.yb(a2);
    			B.subs(a1,a2,a1);	            //对阶
    			C.yb(a1);
    			int p=C.t_t(new String(a1,2,3)); 
    			char b1[]=new char[p+s2.length()];
    			for(int i=0;i<p+s2.length();i++) 
    				b1[i]='0'; 
    			char b2[]=new char[p+s4.length()]; 
    			for(int i=0;i<p+s2.length();i++) 
    				b2[i]='0'; 
    			if(a1[0]=='0'){
    				s1.getChars(0, s1.length(), a1, 0);
    				s2.getChars(0, s2.length(), b1, 0);
    				s4.getChars(0, s4.length(), b2, p);
    			}
    			else{
    				s3.getChars(0, s3.length(), a1, 0);
    				s2.getChars(0, s2.length(), b1, p);
    				s4.getChars(0, s4.length(), b2, 0);
    			}
    			B.subs(b1, b2, b1);	      //尾数相减
    			String s=new String(b1);
    			if(s.startsWith("01")||s.startsWith("10")){	         //右规
    				for(int i=b1.length-1;i>=1;i--)
    					b1[i]=b1[i-1];
    				C.addone(a1);
    			}
    			else if(s.startsWith("000")) {              //左规
    				int t=s.indexOf("1")-2 ;
    				for(int i=0;i<b1.length-t;i++)	
    					b1[i]=b1[i+t];	               //左移
    				for(int i=b1.length-t;i<b1.length;i++) 
    					b1[i]='0';
    				String t_=Long.toBinaryString(t); 
    				char a1_[]=new char[5];
    				for(int i=0;i<5;i++)	
    					a1_[i]='0'; 
    				t_.getChars(0,t_.length(),a1_,a1.length-t_.length()); 	
    				B.subs(a1, a1_, a1);
    			}
    			else if(s.startsWith("111")){
    				int t=s.indexOf("0")-2 ;
    				for(int i=0;i<b1.length-t;i++)	
    					b1[i]=b1[i+t]; 
    				for(int i=b1.length-t;i<b1.length;i++) 
    					b1[i]='0'; 
    				String t_=Long.toBinaryString(t);
    				char a1_[]=new char[5];
    				for(int i=0;i<5;i++)	
    					a1_[i]='0'; 
    				t_.getChars(0,t_.length(),a1_,a1.length-t_.length()); 
    				B.subs(a1, a1_, a1);
    			}
    			if(b1[b1.length-p]=='1'){ //舍入
    				String code=new String(b1,0,b1.length-p); 
    				char c[]=code.toCharArray();
    				C.addone(c); b1=c;
    				String code_=new String(b1); 
    				if(code_.startsWith("01")||code_.startsWith("10")){   	//右规
    					for(int i=c.length-1;i>=1;i--)	
    						c[i]=c[i-1];
    					C.addone(a1);	
    				}
    			}
    			if(a1[0]=='0'&&a1[1]=='1'||a1[0]=='1'&&a1[1]=='0'){
    				subj.setText("结果溢出");
    			}
    			else{
    				C.yb(a1);
    				if(a1[0]=='0') { 
    					a1[0]=' '; a1[1]=(char)('+');
    				}
    				else {
    					a1[0]=' '; a1[0]=(char)('-');
    				} 
    				String code1=new String(a1); 
    				subj.setText(code1);
    				C.yb(b1);
    				if(b1[0]=='0') { 
    					b1[1]='0'; b1[0]=(char)('+');
    				}
    				else {
    					b1[1]='0'; b1[0]=(char)('-');
    				}
    				StringBuffer code2_=new StringBuffer(new String(b1)); 
    				code2_.insert(2,".");
    				String code2=new String(code2_); 
    				subt.setText(code2);
    			}
    		}
    		if(e.getSource()==back){
    			j1.setText(null);j2.setText(null); 
    			t1.setText(null);t2.setText(null); 
    			addj.setText(null);subj.setText(null); 
    			addt.setText(null);subt.setText(null); 
    			setVisible(false);
    		}
    	}
    }
    
    class C{
    	static	void	yb(char a[]){      //双符号位原-补
    		String s=new String(a); 
    		if(s.startsWith("1")){
    			s.getChars(s.lastIndexOf("1"), s.length(), a, s.lastIndexOf("1")); 
    			s=s.substring(2,s.lastIndexOf("1"));	
    			s=s.replaceAll("0", ";");
    			s=s.replaceAll("1", "'");
    			s=s.replaceAll(";", "1");
    			s=s.replaceAll("'", "0");
    			s.getChars(0,s.length(),a,2);
    		}
    	}
    	static int t_t(String s) {
    		int p=0,m=0;
    		for(int i=s.length()-1;i>=0;i--){
    			char c=s.charAt(i);
    			int a=Integer.parseInt(""+c); 
    			p=p+(int)(a*Math.pow(2,m)); m++;
    		}
    		return p;
    	}
    	static void addone(char a[]) {
    		String s=new String(a); 
    		s.getChars(0,s.lastIndexOf("0"),a,0);
    		String ss=s.substring(s.lastIndexOf("0"),s.length()); 
    		ss=ss.replaceAll("0", ";");ss=ss.replaceAll("1", "'");
    		ss=ss.replaceAll(";", "1");ss=ss.replaceAll("'", "0");
    		ss.getChars(0,ss.length(),a,s.lastIndexOf("0"));
    	}
    }
    
    class B{
    	static void adds(char a1[],char a2[],char b[]){
    		int temp=0;int n=a1.length-1;
    		for(int i=n,j=n,m=n;i>=0;i--,j--,m--){
    			if(a1[i]=='0'&&a2[j]=='0'&&temp==0){
    				b[m]='0';temp=0;
    			}
    			else if(a1[i]=='0'&&a2[j]=='1'&&temp==0||a1[i]=='1'&&a2[j]=='0'&&temp==0||a1[i]=='0'&&a2[j]=='0'&&temp==1){
    				b[m]='1';temp=0;
    			}
    			else if(a1[i]=='1'&&a2[j]=='1'&&temp==0||a1[i]=='0'&&a2[j]=='1'&&temp==1||a1[i]=='1'&&a2[j]=='0'&&temp==1){
    				b[m]='0';temp=1;	
    			}
    			else if(a1[i]=='1'&&a2[j]=='1'&&temp==1){
    				b[m]='1';temp=1;
    			}
    		}
    	}
    	static void subs(char a1[],char a2[],char b[]) {
    		String s=new String(a2);
    		s.getChars(s.lastIndexOf("1"), s.length(), a2, s.lastIndexOf("1")); 
    		s=s.substring(0,s.lastIndexOf("1"));
    		s=s.replaceAll("0", ";");s=s.replaceAll("1", "'");
    		s=s.replaceAll(";", "1");s=s.replaceAll("'", "0");
    		s.getChars(0,s.length(),a2,0); B.adds(a1,a2,b);
    	}
    }

[《计组》课设：实现机器数的真值还原（定点小数）、定点小数的单符号位补码加减运算、定点小数的原码一位乘法运算和浮点数的加减运算-Java文档类资源-CSDN下载][-Java_-CSDN]

[60fa162de5b8418ea31cacb8d803d2f8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/9aafb04c275b48cc992dc1af9dc2fd3a.png
[38cabdd6ffdd4cc0a883d7f14d51d89d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/a329e43e5fdd4eb1bbecbe33b1184220.png
[2b80b067c84846d1b6ddacd9f89df178.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/f072b6d0012d4a22bae62dd04d0603d7.png
[8c1e464bf267414b900c7c683cef73cb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/206da86f4d23440589620f6bb2fd4b4c.png
[bacc8204df5f44e3b0e3541fd23822d7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/2db654196ded4cb19d4bed03d288effd.png
[e22e2ed88cdd4d4bb56f906810e50848.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/65806b1c2fe9470c969de2e8d6c90710.png
[74140aacc6a24d858f339c4543983e46.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/e56cd6660e30496bb457377c3d7a7400.png
[-Java_-CSDN]: https://download.csdn.net/download/m0_47097190/87253594