计算机组成原理的Java实现

1 课程设计目的
本课程设计是在学完本课程教学大纲规定的全部内容、完成所有实践环节的基础上，旨在深化学生学习的计算机组成原理课程基本知识，进一步领会计算机组成原理的一些算法，并进行具体实现，提高分析问题、解决问题的综合应用能力。
2 课程设计内容与要求
1、题目：
计算机组成原理算法实现（五）
2、功能：
能够实现机器数的真值还原（定点整数）、定点整数的单符号位补码加减运算、定点整数的原码一位乘法运算和浮点数的加减运算。
3 功能模块详细设计
3.1 主窗体设计

图3-1主界面图 图3-2 口令成功

系统进入（主）窗体的设计：菜单需要在输入口令正确后方可激活使用。口令输入错误时要给出重新输入口令的提示。本次课程设计所用的前端语言是html,css,以及jQuery，后端的逻辑代码是用java写的，本次课程设计本着前端与后端分离的思想设计，前端只负责界面的展示，后端只负责逻辑的部分。
3.2 主体功能
1.login.jsp
该jsp文件为整个程序的前端界面代码。
2.Calculate.css
该css文件负责前端界面的样式。
3.Calculate.js和jquery-1.10.1.js
这些javascript文件负责前端界面的行为，以及与后端的交互。
4.trueNumber.java
该java类负责接收从前端发来的请求和数据，并将机器数的真值响应给前端。
5.dzdfplus.java
该java类负责接收从前端发来的请求和数据，并将定点整数的单符号位补码加减运算结果响应给前端。
6.dzymcf.java
该java类负责接收从前端发来的请求和数据，并将定点整数的原码乘法运算结果响应给前端。
7.fdplusminus.java
该java类负责接收从前端发来的请求和数据，并将浮点数的加减运算结果响应给前端。
3.2.1定点整数真值还原
点击主界面中的机器数真值还原按钮出现如图3-3界面

图3-3定点整数真值还原
在上面的窗体中按“输入”按扭时，将输入焦点设置为最上面的一个文本框上。输入一个机器数（如10011）后，按“原码”、“反码”、“补码”或“移码”按扭中的任一个后，将在第二文本框中显示对应操作的结果。选择“返回”按扭时将关闭此窗体，返回口令登录界面。
定点表示：约定机器中所有数据的小数点位置是固定的。由于约定在固定的位置，所以小数点就不再使用记号“.”来表示。
一般书写所表示的数据称为真值，在计算机中为了表示符号位，通常把符号位和数字位一起编码来表示相应的数，形成了各种数据的存储和表示方法，这些编码称为机器码。常用的机器码有原码、反码、补码和移码。
算法思想：
（1）原码：原码的数值部分是该数的绝对值，最高位表示符号位，最高位为0是正数，最高位为1是负数。所以只需要判断最高位的符号，后面的不需要改变。
（2）反码：正数的反码等于原码，负数的反码等于除符号位外其余二进制数码0变成1，1变成0。负数数值部分先存放到数组里面，然后遍历数组取反，再加上符号转换成字符串响应给前端。
正数： [x]反 = [x]原 = x ；负数： 符号位不变，其余变反
（3）补码：正数的补码等于原码，负数的补码等于反码加1。先将负数数值部分反码存入数组，然后用数组实现二进制加法，最后将数组转为字符串响应给前端。
正数： [x]补= [x]原 ；负数： [x]补= [x]反 +1
（4）移码：是符号位取反的补码，一般用做浮点数的阶码，引入的目的是为了保证浮点数的机器码为全0。
3.2.2定点整数的单符号位补码加减运算
进行定点整数单符号位补码加减法的实现时都是在主窗体选择对应的菜单项后进入对应窗体再进行具体操作。操作时首先选择“输入”按扭输入参与运算的数据，然后再选操作按扭。如图3-4

图3-4定点整数的单符号位补码加减运算

定点整数单符号位补码加减法的实现，输入按钮，删除所有数据并将光标移到第一个输入窗口里面，开始输入，注意是真值的输入，实现定点整数加减法时，首先判断符号位，然后将其转化为其补码形式存入数组，在用数组实现补码的加法，
在实现减法时需将负减数将符号在内全部取反加1，再用数组实现加法，将减法转为加法实现，其中用数组实现加法时需记录最高符号位的进位Cf和最高有效位的进位C0,以判断结果是否溢出。最后将补码结果转为真值输出。
算法思想：
（1）参加运算操作的数都用补码表示。
（2）数据的符号与数据一样参加运算。将数值存入数组运算。
（3）求差时将负减数求补,用求和代替求差, 将减法运算转化为补码的加法运算。
（4）运算结果为补码。最后将补码结果转为真值输出。
（5）最高符号位的进位为Cf，最高数值有效位为C0.
溢出：在定点数机器中,数的大小超出了定点数能表示的范围，叫溢出。
（1）在定点小数机中数的表示范围是-1<x<1，如果运算过程中出现了大于1或者小于－1的情况。
（2）在定点整数机（8位）中数的表示范围是-128<x<127，如果运算过程中出现了大于127或者小于－128的情况。
单符号位法：当最高有效位产生接进位而符号位无进位时，产生正溢；当最高有效位无进位而符号位有进位时，产生负溢。故单符号位溢出的逻辑表达式为V=Cf异或C0。在定点机中，当运算结果发生溢出时表示出错，机器通过逻辑电路自动检查出这种溢出，并进行中断处理。
①Cf=0&&C0=1,结果正溢
②Cf=1&&C0=0,结果负溢
③Cf=0&&C0=0||Cf=1&&C0=1,结果没有溢出

3.2.3 定点整数的原码乘法运算

进行定点整数原码乘法的实现时都是在主窗体选择对应的菜单项后进入对应窗体再进行具体操作。操作时首先选择“输入”按扭输入参与运算的数据，然后再选操作按扭。如图3-5

图3-5 定点整数的原码乘法运算

机器算法： 机器中一种方法是多次采用”加法－移位“的方法来完成，称为串行乘法器，它的硬件结构简单，但是速度慢，目前广泛使用的是流水式阵列乘法器，称为并行乘法器。无符号数m乘以n会产生mn个位积，出现m+n个列和，并行乘法器的关键是快速产生mn个位积，对位积进行相加运算产生m+n个列和。
算法思想：
模拟机器算法：串行乘法器
（1）首先输入被乘数与乘数真值，判断符号位，如果符号位相同结果为正数，如果不同结果为负数，并将其原码存入分别存入两个数组中。
（2）再声明一个部分积数组并初始化为0。
（3）然后开始循环，从乘数数组的最后一位开始循环，到第一位结束循环，如果当前的乘数的最后一位为1，则部分积加上被乘数，然后部分积和乘数数组同时右移一位，部分积左边第一位用0补位，乘数的左边第一位用部分积的最后一位补位，如果当前的乘数的最后一位为0，则部分积与乘数又再次同时右移，一直到乘数第一位结束。
（4）最后将被乘数数组与乘数数组拼接到一个字符串里，在结果前面加上符号位，即可将结果响应给前端。

3.2.4浮点数的加减运算

进行定点整数单符号位补码加减法的实现时都是在主窗体选择对应的菜单项后进入对应窗体再进行具体操作。操作时首先选择“输入”按扭输入参与运算的数据，然后再选操作按扭。如图3-6

图3-6 浮点数的加减运算

数据输入分为阶码和尾数，将两个数的阶码和尾数对应的变形补码表示出来，比较价码大小并完成对阶即小阶向大阶看齐，若对阶时发生溢出则发出提醒，统一阶码后，采用规格化进行尾数求和，对尾数进行舍入处理，判断尾数最末尾情况，用Replace语句实现粗略舍入处理。最后进行变形补码还原。
算法思想：
浮点数的加减法运算分为六个步骤：
（1）0操作数检查
浮点加减运算过程比定点运算过程复杂。如果判知两个操作数ｘ或ｙ中有一个数为0,即可得知运算结果而没有必要再进行后续的一系列操作以节省运算时间。0操作数检查步骤则用来完成这一功能。参加加法运算的数据都是非零，进入下一步。
（2）比较阶码大小并完成对阶
为了便于直观理解,假设两数均以补码表示,阶码采用双符号位,尾数采用单符号位。 两浮点数进行加减，首先要看两数的阶码是否相同，若二数阶码不同，表示小数点位置没有对齐，此时必须使二数阶码相同，这个过程叫作对阶。对阶操作规定使尾数右移，尾数右移后阶码作相应增加，因此对阶时,总是使小阶向大阶看齐。
（3）尾数进行加减运算
对阶结束后，即可进行尾数的求和运算。不论加法运算还是减法运算，都按加法进行操作(减法利用补码减法转换成补码的加法来做)，其方法与定点加减法运算完全一样。
（4）结果规格化
① 采用双符号位表示尾数时，如果两符号位为01或10时，应将结果尾数右移一位，阶码加1（叫“右规”）。
② 如果尾数最高数值位与符号位相同，应将尾数左移，阶码减１，直至数值位最高位与符号位相反（叫“左规”）。
（5）舍入运算
在对阶向右规格化，尾数向右移位，这样被右移的尾数的低位部分会被丢掉，从而造成一定误差，要进行舍入处理。
简单的舍入方法有两种：一种是“0舍1入”法，即如果右移时被丢掉数位的最高位为0则舍去，为1则将尾数的末位做加加1运算。另一种是“恒置1”法，即只要数位被移掉，就在尾数的末尾恒置1。
（6）判断结果是否溢出
阶码为00 011，阶码的符号位为00，根据补码的双符号检测溢出的方法确定阶码不溢出。
4 设计小结
通过本次计算机组成原理课程设计，我不仅仅复习了上学期的学的计算机组成原理的知识，还巩固了前端的知识，复习了html，css和jQurey等语言，以及实现后端用的java语言，提高了动手能力，我感觉到只有不断的敲代码，才能不断地熟练运用它，只有敲出来才能真正的掌握它，不能只停留在理论上，纸上谈兵，只有不断的实践才能有更深的体会，一个方面体会到敲出来的成就感，另一方面体会到自己的不足和短板，才会更有动力继续下去，最后在此基础上进行总结提升对知识的理解。
经过了这次的课程设计，我想，对于我日后的计算机的相关的学习肯定会有诸多好处与影响，为将来的学习生活打下了坚实的基础。以后在遇到这些问题就不会无从下手了。通过此次设计也让我明白了思路即出路，有什么不懂不明白的地方要及时请教或上网查询，只要认真钻研，动脑思考，动手实践，就没有弄不懂的知识，收获颇丰。

参考文献
[1]白中英. 计算机组成原理（第五版）[M]. 北京: 科学出版社, 2010.
[2]耿祥义 张跃平. Java 2实用教程（第五版）[M]. 北京：清华大学出版社, 2017.

源代码清单

/Calculate/src/servlet/trueNumber.java
package servlet;
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
@WebServlet("/trueNumber")
public class trueNumber extends HttpServlet {
private static final long serialVersionUID = 1L;
@Override
protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
resp.setContentType(“text/html;charset=utf-8”);
String result=null;
String number = req.getParameter(“number”);
String name = req.getParameter(“btnname”);
if (name.equals(“yuanma”)) {
result = yuanmaResult(number);
}
if (name.equals(“buma”)) {
result = bumaResult(number);
}
if (name.equals(“fama”)) {
result = famaResult(number);
}
if (name.equals(“yima”)) {
result = yimaResult(number);
}
resp.getWriter().write(result);
}

private String yimaResult(String number) {
	String result;
	if(number.charAt(0)=='0') {
		result = "-";
		result = result + number.substring(1, number.length());
	}
	else {
		result = "+";
		for(int i = 1;i<number.length();i++) {
			if(number.charAt(i)=='0')
				result = result + "1";
			else {
				result = result + "0";
			}
		}
		//System.out.println(result.length());//5
		int arr[] = new int[result.length()-1];
		//System.out.println(arr.length);//4
		for(int j = 1;j<result.length();j++)
			arr[j-1] = (result.charAt(j))-48;
		int lastindex = arr.length-1;
		//System.out.println(arr[lastindex]);//0
		int flag=0;
		if(arr[lastindex]==0) {
			arr[lastindex]=1;
			flag=0;
		}
		else {
				arr[lastindex]=0;
				flag=1;
			}
		for(int k=(lastindex-1);k>=0;k--) {
			arr[k]=arr[k]+flag;
			if(arr[k]==0||arr[k]==1) flag=0;
			if(arr[k]==2) {
				arr[k]=0;
				flag=1;
			}
		}
		result = "+";
		StringBuffer sb = new StringBuffer();
		for(int m=0;m<arr.length;m++)
			sb.append(arr[m]);
		result = result + sb.toString();
		//System.out.println(result);
	}
	return result;
}
private String famaResult(String number) {
	String result;
	if(number.charAt(0)=='0') {
		result = "+";
		result = result + number.substring(1, number.length());
	}
	else {
		result = "-";
		for(int i = 1;i<number.length();i++) {
			if(number.charAt(i)=='0')
				result = result + "1";
			else {
				result = result + "0";
			}
		}
	}
	return result;
}

private String bumaResult(String number) {
	String result;
	if(number.charAt(0)=='0') {
		result = "+";
		result = result + number.substring(1, number.length());
	}
	else {
		result = "-";
		for(int i = 1;i<number.length();i++) {
			if(number.charAt(i)=='0')
				result = result + "1";
			else {
				result = result + "0";
			}
		}
		//System.out.println(result.length());//5
		int arr[] = new int[result.length()-1];
	//System.out.println(arr.length);//4
		for(int j = 1;j<result.length();j++)
			arr[j-1] = (result.charAt(j))-48;
		int lastindex = arr.length-1;
		//System.out.println(arr[lastindex]);//0
		int flag=0;
		if(arr[lastindex]==0) {
			arr[lastindex]=1;
			flag=0;
		}
		else {
				arr[lastindex]=0;
				flag=1;
			}
		for(int k=(lastindex-1);k>=0;k--) {
			arr[k]=arr[k]+flag;
			if(arr[k]==0||arr[k]==1) flag=0;
			if(arr[k]==2) {
				arr[k]=0;
				flag=1;
			}
		}
		result = "-";
		StringBuffer sb = new StringBuffer();
		for(int m=0;m<arr.length;m++)
			sb.append(arr[m]);
		result = result + sb.toString();
		//System.out.println(result);
	}
	return result;
}

private String  yuanmaResult(String number) {
	String result = null;
	if (number.charAt(0) == '0') {
		result = "+";
			} else {
		result = "-";

} }
result = result + number.substring(1, number.length());
//System.out.println(result);
return result;
}
}
/Calculate/src/servlet/dzdfplus.java
package servlet;
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
@WebServlet("/dzdfplus")
public class dzdfplus extends HttpServlet {
private static final long serialVersionUID = 1L;
//存放符号位与最高有效位的进位
int cf=0,c0=0;
protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//设置响应数据格式
resp.setContentType(“text/html;charset=utf-8”);
//存放结果数据
String result=null;
//获取有关数据
String number1 = req.getParameter(“number1”);
String number2 = req.getParameter(“number2”);
String name = req.getParameter(“btnname”);

	//判别请求处理的plus和minus类型
	if(name.equals("plus")) {
		result = plusResult(number1,number2);
	}else {
		result = minusResult(number1,number2);
	}
	if(cf==0&&c0==1) {
		result=result+"(结果正溢出)";
	}
	if(cf==1&&c0==0) {
		result=result+"(结果负溢出)";
	}
	//给前端响应处理结果
	resp.getWriter().write(result);
	
}

/**
 * @param number1  带符号的真值字符串
 * @param number2  带符号的真值字符串
 * @return  单符号补码减法结果
 */
private String plusResult(String number1, String number2) {
		String result = null;
		int[] number1arr= bumaResult(number1);
		int[] number2arr= bumaResult(number2);
		int[] resultarr=binPlus(number1arr,number2arr);
		if(resultarr[0]==0) result="+";
		if(resultarr[0]==1) result="-";
		StringBuffer sb = new StringBuffer();		
		for(int m=1;m<resultarr.length;m++)
			sb.append(resultarr[m]);
		result = result + sb.toString();
		System.out.println(result);
		return result;
	}

/**
 * @param number1：带符号的真值字符串
 * @param number2    带符号的真值字符串
 * @return 单符号补码减法结果
 */
private String minusResult(String number1, String number2) {
	String result= null;
	int[] number1arr= bumaResult(number1);
	int[] number2arr= bumaResult(number2);
	for(int i=0;i<number2arr.length;i++)
	{
		if(number2arr[i]==0) number2arr[i]=1;
		else number2arr[i]=0;
	}
	int lastindex = number2arr.length-1;
	//System.out.println(arr[lastindex]);//0
	int flag=0;
	if(number2arr[lastindex]==0){
		number2arr[lastindex]=1;
		flag=0;
	}
	else {
		number2arr[lastindex]=0;
			flag=1;
		}
	for(int k=(lastindex-1);k>=0;k--) {
		number2arr[k]=number2arr[k]+flag;
		if(number2arr[k]==0||number2arr[k]==1) flag=0;
		if(number2arr[k]==2) {
			number2arr[k]=0;
			flag=1;
		}
	}
	int[] resultarr=binPlus(number1arr,number2arr);
	if(resultarr[0]==0) result="+";
	if(resultarr[0]==1) result="-";
	StringBuffer sb = new StringBuffer();		
	for(int m=1;m<resultarr.length;m++)
		sb.append(resultarr[m]);
	result = result + sb.toString();
	System.out.println(result);
	return result;	
}

/**
 * @param number 输入一个带符号位的真值字符串
 * @return  结果为补码的整型数组
 */
private int[] bumaResult(String number) {
	String result;
	int a[];
	if(number.charAt(0)=='+') {
		result = "0";
		result = result + number.substring(1, number.length());
		int arr[] = new int[result.length()];
		for(int j = 0;j<result.length();j++)
			arr[j] = (result.charAt(j))-48;
		a=arr;
	}
	else {
		result = "1";
		for(int i = 1;i<number.length();i++) {
			if(number.charAt(i)=='0')
				result = result + "1";
			else {
				result = result + "0";
			}
		}
		//System.out.println(result.length());//5
		int arr[] = new int[result.length()];
		//System.out.println(arr.length);//4
		for(int j = 0;j<result.length();j++)
			arr[j] = (result.charAt(j))-48;
		int lastindex = arr.length-1;
		//System.out.println(arr[lastindex]);//0
		int flag=0;
		if(arr[lastindex]==0) {
			arr[lastindex]=1;
			flag=0;
		}
		else {
				arr[lastindex]=0;
				flag=1;
			}
		for(int k=(lastindex-1);k>=0;k--) {
			arr[k]=arr[k]+flag;
			if(arr[k]==0||arr[k]==1) flag=0;
			if(arr[k]==2) {
				arr[k]=0;
				flag=1;
			}
		}
		a=arr;
	}
	return a;
}

/**
 * @param number1arr  存放二进制的整型数组
 * @param number2arr  存放二进制的整型数组
 * @return 返回二进制和的整型数组
 */
public int[] binPlus(int[] number1arr, int[] number2arr) {
	int[] result=new int[number1arr.length];
	int flag=0;
	for (int i = (number1arr.length-1); i >=0 ; i--) {
		result[i]=number1arr[i]+number2arr[i]+flag;
		if(result[i]==0||result[i]==1) {
			flag=0;
		}
		if(result[i]==2) {
			result[i]=0;
			flag=1;
		}
		if(result[i]==3) {
			result[i]=1;
			flag=1;
		}
		if(i==1) c0=flag;
	}
	cf=flag;
	return result;
}

}
/Calculate/src/servlet/dzymcf.java
package servlet;
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
@WebServlet("/dzymcf")
public class dzymcf extends HttpServlet {
private static final long serialVersionUID = 1L;

protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
	resp.setContentType("text/html;charset=utf-8");
	//获取有关的数据
	String number1 = req.getParameter("number3");
	// System.out.println(number1);
	String number2 = req.getParameter("number4");
	// System.out.println(number2);
	//存放结果
	String result;
	int length1 = number1.length();
	int length2 = number2.length();
	if (length1 != length2) {
		result = "error";
	} else {
		//存放部分积
		int a[] = new int[length1 - 1];
		//存放乘数
		int b[] = new int[length1 - 1];
		//存放被乘数
		int a1[] = new int[length1 - 1];
		//符号处理
		if ((number1.charAt(0)) == (number2.charAt(0)))
			result = "+";
		else
			result = "-";
		//把字符串转为整型数组
		for (int i = 1; i < length1; i++) {
			a1[i - 1] = number1.charAt(i) - 48;
		}
		for (int j = 1; j < length1; j++) {
			b[j - 1] = number2.charAt(j) - 48;
		}
		//初始化部分积
		for (int j = 0; j < b.length; j++) {
			a[j] = 0;
		}
		//核心代码
		for (int i = a.length - 1; i >= 0; i--) {
			if (b[a.length - 1] == 0) {
				yiwei(a, b);
			} else if (b[a.length - 1] == 1) {
				a = binPlus(a, a1);
				yiwei(a, b);
			}
		}
		
		//将数组转化为字符串
		StringBuffer sb = new StringBuffer();
		for (int m = 0; m < a.length; m++)
			sb.append(a[m]);
		for (int m = 0; m < b.length; m++)
			sb.append(b[m]);
		result = result + sb.toString();
	}
	resp.getWriter().write(result);
}

//移位
private void yiwei(int a[], int b[]) {
	int alast = a[a.length - 1];
	for (int j = a.length - 1; j >= 1; j--) {
		a[j] = a[j - 1];
	}
	a[0] = 0;
	for (int j = a.length - 1; j >= 1; j--) {
		b[j] = b[j - 1];
	}
	b[0] = alast;
}

/**
 * @param number1arr  存放二进制的整型数组
 * @param number2arr  存放二进制的整型数组
 * @return 返回二进制和的整型数组
 */
//两个存放0，1的数组相加
private int[] binPlus(int[] number1arr, int[] number2arr) {
	int[] result = new int[number1arr.length];
	int flag = 0;
	for (int i = (number1arr.length - 1); i >= 

0; i–) {
result[i] = number1arr[i] + number2arr[i] + flag;
if (result[i] == 0 || result[i] == 1) {
flag = 0;
}
if (result[i] == 2) {
result[i] = 0;
flag = 1;
}
if (result[i] == 3) {
result[i] = 1;
flag = 1;
}
}
return result;
}
}
/Calculate/src/servlet/fdplusminus .java
package servlet;
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
@WebServlet("/fdplusminus")
public class fdplusminus extends HttpServlet {
private static final long serialVersionUID = 1L;
protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
resp.setContentType(“text/html;charset=utf-8”);
//获取相关数据
String jiema1= req.getParameter(“jiema1”);
String weishu1 = req.getParameter(“weishu1”);
String jiema2 = req.getParameter(“jiema2”);
String weishu2 = req.getParameter(“weishu2”);
String btnname = req.getParameter(“btnname”);
//存放结果的字符串
String aresultweishu = null;
String aresultjiema =null;
//存放加数与被加数的数组
int ajiema[]=new int[jiema1.length()+1];
int aweishu[]=new int[weishu1.length()+1];
int bjiema[] = new int[jiema2.length()+1];
int bweishu[] = new int[weishu2.length()+1];
//存放结果的数组
int resultweishu[] = new int[weishu2.length()+1];
int resultjiema[] = new int[jiema1.length()+1];
//将阶码字符串真值装换为整型数组
ajiema = bumaResult(jiema1);
//将尾数的"0.“去掉
String weishu1bumaString = weishu1.replaceFirst(“0.”,”");
//将尾数字符串真值装换为整型数组
aweishu = bumaResult(weishu1bumaString);
bjiema = bumaResult(jiema2);
String weishu2bumaString = weishu2.replaceFirst(“0.”,"");
bweishu = bumaResult(weishu2bumaString);

		//对阶
		String chazhi = minusResult(jiema1,jiema2);	
		String chazhibumaString = buma1Result(chazhi);
		int yiweisum = Integer.parseInt(chazhibumaString, 2);
		
		//移位
		int a[] = new int[(-yiweisum)];
		if(yiweisum<0) {
			resultjiema = bjiema;
			int lastindex = aweishu.length+yiweisum;
			for(int j=0;j<(-yiweisum);j++)
			{
				a[j]=aweishu[lastindex];
				lastindex = lastindex + 1;
			}
			aweishu = rightMove(aweishu,-yiweisum);
		}
		else {
			resultjiema = ajiema;
			//将移位出去的数保存到a数组
			int lastindex = bweishu.length+yiweisum;
			for(int j=0;j<(-yiweisum);j++)
			{
				a[j]=bweishu[lastindex];
				lastindex = lastindex + 1;
			}
			bweishu = rightMove(bweishu,yiweisum);
		}
		
		//System.out.println(a[0]);
		
		//尾数相加
		if(btnname.equals("plus")) {
			resultweishu = binPlus(aweishu, bweishu);
		}
		else if(btnname.equals("minus")) {
			for(int i=0;i<bweishu.length;i++) {
				if(bweishu[i]==0) bweishu[i]=1;
				else {
					bweishu[i] = 0;
				}
			}
			int temp1[] = new int[bweishu.length];
			for(int g = 0;g<temp1.length;g++) {
				if(g==temp1.length-1) temp1[g]=1;
				else {
					temp1[g]=0;
				}
			}
			bweishu=binPlus(bweishu,temp1);
			resultweishu = binPlus(aweishu, bweishu);
		}
	
		//结果规范化
		if((resultweishu[0]+resultweishu[1])==1) {
			//尾数右移1位
			for(int i = resultweishu.length-1;i>=1;i--) {
				a[i]=a[i-1];
				}
			//阶码加1
			StringBuffer sb = new StringBuffer();
			for(int m=0;m<resultjiema.length;m++)
			{
				sb.append(resultjiema[m]);
				System.out.println(resultjiema[m]);
			}
			int resultjiema1=Integer.parseInt(sb.toString(),2);
			resultjiema1=resultjiema1+1;
			aresultjiema = Integer.toBinaryString(resultjiema1);
		}
		else {
			//尾数左移j位
			int b=0;
			for(int j=0;j<resultweishu.length;j++) {
				if((resultweishu[0]==0&&resultweishu[1]==0&&resultweishu[2]==1)||(resultweishu[0]==1&&resultweishu[1]==1&&resultweishu[2]==0))
					{
						if((j-1)<a.length&&a[j]==1) {
							int[] temp = new int[resultweishu.length];
							for(int k = 0;k<temp.length;k++) {
								if(k==temp.length-1) temp[k]=1;
								else temp[k]=0;
							}
						 resultweishu=binPlus(resultweishu, temp);
						}
						b=j;
						break;
					}
					for(int i = 0;i<resultweishu.length-1;i++) {
						resultweishu[i]=resultweishu[i+1];
				if((i==resultweishu.length-2)&&j<a.length){
						resultweishu[i+1]=a[j];
				   }
				if(j>=a.length) {
					resultweishu[i+1]=0;
				}
				}
			}
			//阶码减b
			StringBuffer sb = new StringBuffer();
			StringBuffer sb1 = new StringBuffer();
			for(int m=0;m<resultjiema.length;m++)
				sb.append(resultjiema[m]);
			int resultjiema1=Integer.parseInt(sb.toString(),2);
			resultjiema1=resultjiema1-b;		
			aresultjiema = Integer.toBinaryString(resultjiema1);
			for(int i=0;i<resultweishu.length;i++) {
				sb1.append(resultweishu[i]);			
				}
			aresultweishu = sb1.toString();	
			//System.out.println(aresultweishu);
			if(aresultjiema.startsWith("1"))
			{
					int tmep3[] =new int[aresultjiema.length()-2];
					int temp4[] =new int[aresultjiema.length()-2];
					for(int t=0;t<tmep3.length;t++) {
						tmep3[t]=aresultjiema.charAt(t+2)-48;
						if(tmep3[t]==0) tmep3[t]=1;
						else tmep3[t]=0;
						if(t==(tmep3.length-1)) temp4[t]=1;
						else temp4[t]=0;
					}
					tmep3=binPlus(tmep3,temp4);
					StringBuffer sb2 = new StringBuffer();
					for(int i=0;i<tmep3.length;i++) {
						sb2.append(tmep3[i]);			
						}
					aresultjiema = sb2.toString();
					aresultjiema = "-"+aresultjiema;
			}
			else {
				aresultjiema = "+"+aresultjiema.substring(2,aresultjiema.length());
			}
			
			System.out.println(aresultjiema);
			
			if(aresultweishu.startsWith("0")) {
				aresultweishu = "+0."+aresultweishu.substring(2,aresultweishu.length());
			}
			else {
				int s[] =new int[aresultweishu.length()-2];
				int d[] =new int[aresultweishu.length()-2];
				for(int t=0;t<s.length;t++) {
					s[t]=aresultweishu.charAt(t+2)-48;
					if(s[t]==0) s[t]=1;
					else s[t]=0;
					if(t==(s.length-1)) d[t]=1;
					else d[t]=0;
				}
				s=binPlus(s,d);
				StringBuffer sb2 = new StringBuffer();
				for(int i=0;i<s.length;i++) {
					sb2.append(s[i]);			
					}
				aresultweishu = sb2.toString();
				aresultweishu = "-0."+aresultweishu;
			}
			System.out.println(aresultweishu);	
		}  
		String str="{\"jiema\":\""+aresultjiema+"\",\"weishu\":\""+aresultweishu+"\"}";
		resp.getWriter().write(str);
	}
	
	//右移
	public int[] rightMove(int a[],int count) {
		for(int j=1;j<=count;j++) {
			for(int i = a.length-1;i>=1;i--) {
			a[i]=a[i-1];
			}
		}
		return a;
	}
	/**
	 * @param number 输入一个带符号位的真值字符串
	 * @return  结果为补码的整型数组
	 */
	private int[] bumaResult(String number) {
		String result;
		int a[];
		if(number.charAt(0)=='+') {
			result = "00";
			result = result + number.substring(1, number.length());
			int arr[] = new int[result.length()];
			for(int j = 0;j<result.length();j++)
				arr[j] = (result.charAt(j))-48;
			a=arr;
		}
		else {
			result = "11";
			for(int i = 1;i<number.length();i++) {
				if(number.charAt(i)=='0')
					result = result + "1";
				else {
					result = result + "0";
				}
			}	
			int arr[] = new int[result.length()];
			for(int j = 0;j<result.length();j++)
				arr[j] = (result.charAt(j))-48;
			int lastindex = arr.length-1;
			int flag=0;
			if(arr[lastindex]==0) {
				arr[lastindex]=1;
				flag=0;
			}
			else {
					arr[lastindex]=0;
					flag=1;
				}
			for(int k=(lastindex-1);k>=0;k--) {
				arr[k]=arr[k]+flag;
				if(arr[k]==0||arr[k]==1) flag=0;
				if(arr[k]==2) {
					arr[k]=0;
					flag=1;
				}
			}
			a=arr;
		}
		return a;
	}
	/**
	 * @param number1：带符号的真值字符串
	 * @param number2    带符号的真值字符串
	 * @return 单符号补码减法结果
	 */
	private String minusResult(String number1, String number2) {
		String result= null;
		int[] number1arr= bumaResult(number1);
		int[] number2arr= bumaResult(number2);
		for(int i=0;i<number2arr.length;i++)
		{
			if(number2arr[i]==0) number2arr[i]=1;
			else number2arr[i]=0;
		}
		int lastindex = number2arr.length-1;
		//System.out.println(arr[lastindex]);//0
		int flag=0;
		if(number2arr[lastindex]==0) {
			number2arr[lastindex]=1;
			flag=0;
		}
		else {
			number2arr[lastindex]=0;
				flag=1;
			}
		for(int k=(lastindex-1);k>=0;k--) {
			number2arr[k]=number2arr[k]+flag;
			if(number2arr[k]==0||number2arr[k]==1) flag=0;
			if(number2arr[k]==2) {
				number2arr[k]=0;
				flag=1;
			}
		}
		int[] resultarr=binPlus(number1arr,number2arr);
		if(resultarr[0]==0) result="+";
		if(resultarr[0]==1) result="-";
		StringBuffer sb = new StringBuffer();		
		for(int m=1;m<resultarr.length;m++)
			sb.append(resultarr[m]);
		result = result + sb.toString();
		//System.out.println(result);
		return result;	
   }		
	/**
	 * @param number1arr  存放二进制的整型数组
	 * @param number2arr  存放二进制的整型数组
	 * @return 返回二进制和的整型数组
	 */
	public int[] binPlus(int[] number1arr, int[] number2arr) {
		int[] result=new int[number1arr.length];
		int flag=0;
		for (int i = (number1arr.length-1); i >=0 ; i--) {
			result[i]=number1arr[i]+number2arr[i]+flag;
			if(result[i]==0||result[i]==1) {
				flag=0;
			}
			if(result[i]==2) {
				result[i]=0;
				flag=1;
			}
			if(result[i]==3) {
				result[i]=1;
				flag=1;
			}		
		}
		return result;
	}
	
	/**
	 * @param number 输入一个带符号位的真值字符串
	 * @return  结果为补码的整型字符串
	 */
	private String buma1Result(String number) {
		String result;
		if(number.charAt(0)=='0') {
			result = "+";
			result = result + number.substring(1, number.length());
		}
		else {
			result = "-";
			for(int i = 1;i<number.length();i++) {
				if(number.charAt(i)=='0')
					result = result + "1";
				else {
					result = result + "0";
				}
			}
			//System.out.println(result.length());//5
			int arr[] = new int[result.length()-1];
//System.out.println(arr.length);//4
			for(int j = 1;j<result.length();j++)
				arr[j-1] = (result.charAt(j))-48;
			int lastindex = arr.length-1;
			//System.out.println(arr[lastindex]);//0
			int flag=0;
			if(arr[lastindex]==0) {
				arr[lastindex]=1;
				flag=0;
			}
			else {
					arr[lastindex]=0;
					flag=1;
				}
			for(int k=(lastindex-1);k>=0;k--) {
				arr[k]=arr[k]+flag;
				if(arr[k]==0||arr[k]==1) flag=0;
				if(arr[k]==2) {
					arr[k]=0;
					flag=1;
				}
			}
			result = "-";
			StringBuffer sb = new StringBuffer();
			for(int m=0;m<arr.length;m++)
				sb.append(arr[m]);
			result = result + sb.toString();
			//System.out.println(result);
		}
		return result;
	}

}
/Calculate/WebContent/css/Calculate.css
@charset “UTF-8”;
html, body {
height: 100%;
overflow: auto;
}
#box {
position:relative;
padding: 0px;
margin: 30px auto;
height: 500px;
width: 650px;
background: #CAE1FF;
border-radius: 8px;
border: thin solid black;
}
#header {
width: 650px;
height: 35px;
background: white;
border-bottom: 7px solid #6495ED;
border-top-left-radius: 8px;
border-top-right-radius: 8px;
padding: auto 1em;
color: #6495ED;
font-size: 20px;
line-height: 35px;
font-style: italic;
}
#nav ul {
display: flex;
flex-direction: row;
justify-content: space-around;
padding: 0px;
margin: 0px;
}
#nav ul li {
display: inline-block;
height: 30px;
line-height: 30px;
padding: 3px 7px;
display: inline-block;
}
#nav ul li:hover {
background-color: #6495ED;
}
.biaoti {
color: #6495ED;
font-size: 20px;
margin: 60px auto;
text-align: center;
}
#form {
box-sizing: border-box;
color: #6495ED;
margin: 100px auto;
height: 100px;
padding: 0px;
width: 100%;
text-align: center;
}
.psw {
margin-bottom: 50px;
margin-left: 30px;
}
#test1 {
margin-left:-5px;
}
#test2{
height:30px;
width:50px;
}
#calculateor {
width: 100%;
height: 100%;
margin-top: 10px;
text-align: center;
vertical-align: middle;
}
#bangzhu {
font-size: 17px;
color: black;
width:100%;
heigth:300px;
text-indent:34px;
margin-top:-45px;
line-height:20px;
}
.btns{
width:100%;
height:30px;
margin-bottom:30px;
display:flex;
flex-direction: row;
flex-wrap: nowrap;
justify-content:space-around;
}
#jiema{
width:60%;
height:200px;
padding:0px;
}
#weishu{
}
#jw{
display:flex;
flex-flow:row nowrap;
}
/Calculate/WebContent/js/Calculate.js
$(function() {
var currentindex = 0;
$(’#test2’).click(function() {
var test1 = $(’#test1’).val();
if (test1 == ‘’) {
alert(“口令正确！！”);
$(’#login’).css({
display : “none”
});
$(’#nav’).css({
display : “block”
});
$(’#container>div’).eq(currentindex).css({
display : “block”
});

			$('#nav>ul>li')[currentindex].style.background = '#6495ED';
			
		} else {
			alert("口令错误！！");
		}
	})
	$('#nav ul>li').mouseenter(function(){
		$(this).css({
			background : "#6495ED"
		});
		
	})
	$('#nav ul>li').mouseleave(function(){
		$(this).css({
			background : "#CAE1FF"
		});
		
	})
	$('#nav ul>li').click(function() {
		$('#container>div')[currentindex].style.display = 'none';
		$('#nav ul>li')[currentindex].style.background = '#CAE1FF';
		$(this).css({
			background : "#6495ED"
		});
		var index = $(this).index();
		$('#container>div')[index].style.display = 'block';
		currentindex = index;
	})
	
	$('.in').click(function(){
		$('.inputs').val('');
		$('.inputs').focus();
	})
	
	$('.return').click(function(){
		//alert(currentindex);
		$('#login').css({
			display : "block"
		});
		$('#container>div').css({
			display : "none"
		});
		$('#nav').css({
			display : "none"
		});
		$('#test1').val('');
		$('#test1').focus();
	})
	
	$('.submit01').click(function(){
		var btnname = $(this).attr("name");
		var value = $('#ins').val();
		//alert(btnname);
		if(value=='') alert("请输入合法数据!!");
		else{
		$.ajax({
		    type:'POST',
		    url:'trueNumber',
		    async:"true",
		    dataType:'text',
		    data:{number:value,
		    	btnname:btnname	
		    },
		    success:function(data){
		        $("#outs").val(data);
		    },
		    error:function(jqXHR){
		    }
		});
		}
	})
	
	$('.submit02').click(function(){
		var btnname = $(this).attr("name");
		var value1 = $('#number1').val();
		var value2 = $('#number2').val();
		if(value1==''||value2=='') alert("请输入合法数据!!");
		//alert(btnname);
		else{
		$.ajax({
		    type:'POST',
		    url:'dzdfplus',
		    async:"true",
		    dataType:'text',
		    data:{number1:value1,
		    	number2:value2,
		    	btnname:btnname	
		    },
		    success:function(data){
		    	if(btnname=="plus"){
		    		$("#out1").val(data);
		    	}
		    	else{
		    		$("#out2").val(data);
		    	}
		    },
		    error:function(jqXHR){
		    }
		});
	  }
	})
	
	$('#submit03').click(function(){
		var value3 = $('#number3').val();
		var value4 = $('#number4').val();
		if(value3==''||value4=='') alert("请输入合法数据!!");
		//alert(btnname);
		else{
		$.ajax({
		    type:'POST',
		    url:'dzymcf',
		    async:"true",
		    dataType:'text',
		   data:{number3:value3,
		    	number4:value4,
		    },
		    success:function(data){
		    	if(data=="error")
		    		alert("请输入等长的原码!!");
		    	else $("#out3").val(data);
		    },
		    error:function(jqXHR){
		    }
		});
	  }
	})
	
	$('.submit04').click(function(){
		Var btnname = $(this).attr("name");
		var jiema1 = $('#jiema1').val();
		var weishu1 = $('#weishu1').val();
		var jiema2 = $("#jiema2").val();
		var weishu2 = $("#weishu2").val();
		if(jiema1==''||weishu1==''||jiema2==''||weishu2=='') alert("请输入合法数据!!");
		else{
		$.ajax({
		    type:'POST',
		    url:'fdplusminus',
		    async:"true",
		    dataType:'text',
		    data:{
		    	jiema1:jiema1,
		    	weishu1:weishu1,
		    	jiema2:jiema2,
		    	weishu2:weishu2,
		    	btnname:btnname	
		    },
		    success:function(data){
		    	var data=JSON.parse(data);
		    	if(btnname=="plus"){
		    		//alert(data.jiema);
		    		$("#plusjiema").val(data.jiema);
		    		$("#plusweishu").val(data.weishu);
		    	}
		    	else if(btnname=="minus"){
		    		$("#minusjiema").val(data.jiema);
		    		$("#minusweishu").val(data.weishu);
		    	}			    	
		    },
		    error:function(jqXHR){
		    }
		});
		}
	})	})