20192321 实验四 《数据结构与面向对象程序设计》实验报告
20192321 实验四 《数据结构与面向对象程序设计》实验报告
课程：《程序设计与数据结构》
班级：1923
姓名：李锦程
学号：20192321
实验教师：王志强
实验日期：2020年10月8日
必修/选修：必修
1.实验内容
- （一）Java Socket编程
1.学习蓝墨云上教材《Java和Android编程》“第16章 输入/输出 ”和“第22章 网络”，学习JavaSocket编程
2.结对编程。结对伙伴A编写客户端SocketClient.java，结对伙伴B编写服务器端。
3.截图加学号水印上传蓝墨云，代码push到码云，并撰写实验报告。 - （二）Java和密码学
以结对的方式完成Java密码学相关内容的学习（帖子中所有代码和相关知识点需要学习）。提交学习成果码云链接和代表性成果截图，要有学号水印。 - （三）编写有理数/复数计算器
结对编程，结对伙伴A编写有理数计算器。结对伙伴B编写复数计算器。截图加水印上传蓝墨云，代码push码云。 - （四）远程有理数计算器
结对编程，结对伙伴A编程实现客户端，结果伙伴B实现服务器端。
客户端通过键盘输入一个有理数计算的公式（例如：1/4 + 1/6 = ）,并把该公式以字符串的形式发送给伙伴B（服务器端），服务器端根据字符串计算出结果为5/12,并把结果返回给客户端A，A收到结果后输出结果。截图加水印上传蓝墨云，代码push码云。 - （五）远程复数计算器
结对编程，结对伙伴B编程实现客户端，结果伙伴A实现服务器端。
客户端通过键盘输入一个有理数计算的公式（例如：1/4 + 1/6 = ）,并把该公式以字符串的形式发送给伙伴A（服务器端），服务器端根据字符串计算出结果为5/12,并把结果返回给客户端B，B收到结果后输出结果。截图加水印上传蓝墨云，代码push码云。
注意实验四（4）和实验四（5），一个人不能仅实现客户端，必须实现一个客户端和服务器，否则两个实验均不得分！！！ - （六）实验报告
在规定时间前发表博客，标题“学号 实验四 《数据结构与面向对象程序设计》实验报告”
2.实验过程及结果
（一）Java Socket编程
//import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
public class server {
public static void main(String[] args) throws IOException {
//1.建立一个服务器Socket(ServerSocket)绑定指定端口
ServerSocket serverSocket=new ServerSocket(8809);
//2.使用accept()方法阻止等待监听，获得新连接
Socket socket=serverSocket.accept();
//3.获得输入流
InputStream inputStream=socket.getInputStream();
BufferedReader bufferedReader=new BufferedReader(new InputStreamReader(inputStream));
//获得输出流
OutputStream outputStream=socket.getOutputStream();
PrintWriter printWriter=new PrintWriter(outputStream);
//4.读取用户输入信息
String info=null;
System.out.println("服务器已经建立......");
while(!((info = bufferedReader.readLine()) ==null)){
System.out.println("我是服务器，用户信息为：" + info);
}
//给客户一个响应
String reply="welcome";
printWriter.write(reply);
printWriter.flush();
//5.关闭资源
printWriter.close();
outputStream.close();
bufferedReader.close();
inputStream.close();
socket.close();
serverSocket.close();
}
}
（二）Java和密码学
参考 http://www.cnblogs.com/rocedu/p/6683948.html
以结对的方式完成Java密码学相关内容的学习（帖子中所有代码和相关知识点需要学习）。提交学习成果码云链接和代表性成果截图，要有学号水印。
（三）编写有理数/复数计算器
结对编程，结对伙伴A编写有理数计算器。结对伙伴B编写复数计算器。截图加水印上传蓝墨云，代码push码云。
复数计算器
package Complex;
public class ComplexNumber
{
double Realpart;
double Imagepart;
public double getRealpart() {
return Realpart;
}
public double getImagepart() {
return Imagepart;
}
public void setRealpart(double realpart) {
Realpart = realpart;
}
public void setImagepart(double imagepart) {
Imagepart = imagepart;
}
public ComplexNumber()
{
}
public ComplexNumber(double realpart, double imagepart) {
Realpart = realpart;
Imagepart = imagepart;
}
@Override
public String toString() {
return "ComplexNumber{" +
"Realpart=" + Realpart +
", Imagepart=" + Imagepart +
'}';
}
}
package Complex;
public class ComplexNumCal extends ComplexNumber implements Comparable
{
public ComplexNumCal(double realpart, double imagepart)
{super(realpart,imagepart);}
public ComplexNumCal (){}
public ComplexNumCal add(ComplexNumCal a,ComplexNumCal b)
{
ComplexNumCal temp=new ComplexNumCal();
temp.Realpart=a.Realpart+b.Realpart;
temp.Imagepart=a.Imagepart+b.Imagepart;
return temp;
}
public ComplexNumCal contract(ComplexNumCal a,ComplexNumCal b)
{
ComplexNumCal temp=new ComplexNumCal();
temp.Realpart=a.Realpart-b.Realpart;
temp.Imagepart = a.Imagepart - b.Imagepart;
return temp;
}
public ComplexNumCal multi(ComplexNumCal a,ComplexNumCal b)
{
ComplexNumCal temp=new ComplexNumCal();
temp.Realpart = a.Realpart * b.Realpart - a.Imagepart * b.Imagepart;
temp.Imagepart = a.Realpart * b.Imagepart + a.Imagepart * b.Realpart;
return temp;
}
public ComplexNumCal div(ComplexNumCal a,ComplexNumCal b)
{
ComplexNumCal temp=new ComplexNumCal();
temp.Realpart = a.Realpart * b.Realpart - a.Imagepart * b.Imagepart;
temp.Imagepart = a.Realpart * b.Imagepart + a.Imagepart * b.Realpart;
return temp;
}
public int compareTo(ComplexNumCal o) {
Integer i=-5;
if((this.Realpart+this.Imagepart)<(o.Realpart+o.Imagepart))
i=-1;
else if((this.Realpart+this.Imagepart)==(o.Realpart+o.Imagepart))
i=0;
else if((this.Realpart+this.Imagepart)>(o.Realpart+o.Imagepart))
i=1;
return i;
}
@Override
public int compareTo(Object o) {
return 0;
}
}
有理数计算器
package myRocket;
import duotai.Pets;
public class RationNumber {
private int numerator,denominator;
public RationNumber(int numer,int denom)
{
if(denom==0)
denom=1;
if(denom<0)
{
numer=numer*-1;
denom=denom*-1;
}
numerator=numer;
denominator=denom;
}
public RationNumber(){}
public int getNumerator() {
return numerator;
}
public int getDenominator() {
return denominator;
}
public RationNumber reciprocal()
{
return new RationNumber(denominator, numerator);
}
public RationNumber add(RationNumber op2)
{
int commonDenominator=denominator*op2.getDenominator();
int numerator1=numerator*op2.getDenominator();
int numerator2=op2.getNumerator()*denominator;
int sum=numerator1+numerator2;
return new RationNumber(sum, commonDenominator);
}
public RationNumber subtract(RationNumber op2)
{
int commonDenominator=denominator*op2.getDenominator();
int numerator1=numerator*op2.getDenominator();
int numerator2=op2.getNumerator()*denominator;
int difference=numerator1-numerator2;
return new RationNumber(difference, commonDenominator);
}
public RationNumber multiply(RationNumber op2)
{
int numer=numerator*op2.getDenominator();
int denom=denominator*op2.getDenominator();
return new RationNumber(numer, denom);
}
public RationNumber divide(RationNumber op2)
{
return multiply(op2.reciprocal());
}
private void reduce()
{
if(numerator!=0)
{
int common=gcd(Math.abs(numerator),denominator);
numerator=numerator/common;
denominator=denominator/common;
}
}
private int gcd(int num1,int num2)
{
while (num1!=num2)
if(num1>num2)
num1=num1-num2;
else
num2=num2-num1;
return num1;
}
@Override
public String toString() {
return "RationNumber{" +
"numerator=" + numerator +
", denominator=" + denominator +
'}';
}
}
package myRocket;
import duotai.Pets;
public class RationNumber {
private int numerator,denominator;
public RationNumber(int numer,int denom)
{
if(denom==0)
denom=1;
if(denom<0)
{
numer=numer*-1;
denom=denom*-1;
}
numerator=numer;
denominator=denom;
}
public RationNumber(){}
public int getNumerator() {
return numerator;
}
public int getDenominator() {
return denominator;
}
public RationNumber reciprocal()
{
return new RationNumber(denominator, numerator);
}
public RationNumber add(RationNumber op2)
{
int commonDenominator=denominator*op2.getDenominator();
int numerator1=numerator*op2.getDenominator();
int numerator2=op2.getNumerator()*denominator;
int sum=numerator1+numerator2;
return new RationNumber(sum, commonDenominator);
}
public RationNumber subtract(RationNumber op2)
{
int commonDenominator=denominator*op2.getDenominator();
int numerator1=numerator*op2.getDenominator();
int numerator2=op2.getNumerator()*denominator;
int difference=numerator1-numerator2;
return new RationNumber(difference, commonDenominator);
}
public RationNumber multiply(RationNumber op2)
{
int numer=numerator*op2.getDenominator();
int denom=denominator*op2.getDenominator();
return new RationNumber(numer, denom);
}
public RationNumber divide(RationNumber op2)
{
return multiply(op2.reciprocal());
}
private void reduce()
{
if(numerator!=0)
{
int common=gcd(Math.abs(numerator),denominator);
numerator=numerator/common;
denominator=denominator/common;
}
}
private int gcd(int num1,int num2)
{
while (num1!=num2)
if(num1>num2)
num1=num1-num2;
else
num2=num2-num1;
return num1;
}
@Override
public String toString() {
return "RationNumber{" +
"numerator=" + numerator +
", denominator=" + denominator +
'}';
}
}
（四）远程有理数计算器
结对编程，结对伙伴A编程实现客户端，结果伙伴B实现服务器端。
客户端通过键盘输入一个有理数计算的公式（例如：1/4 + 1/6 = ）,并把该公式以字符串的形式发送给伙伴B（服务器端），服务器端根据字符串计算出结果为5/12,并把结果返回给客户端A，A收到结果后输出结果。截图加水印上传蓝墨云，代码push码云。
（五）远程复数计算器
结对编程，结对伙伴B编程实现客户端，结果伙伴A实现服务器端。
客户端通过键盘输入一个有理数计算的公式（例如：1/4 + 1/6 = ）,并把该公式以字符串的形式发送给伙伴A（服务器端），服务器端根据字符串计算出结果为5/12,并把结果返回给客户端B，B收到结果后输出结果。截图加水印上传蓝墨云，代码push码云。
注意实验四（4）和实验四（5），一个人不能仅实现客户端，必须实现一个客户端和服务器，否则两个实验均不得分！！！
package myRocket;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.Socket;
import java.nio.charset.StandardCharsets;
import java.util.Scanner;
public class 客户端初步尝试 {
public static void main(String[] args) throws IOException {
String host = "127.0.0.1";
int port = 8080;
//Socket socket = new Socket(host, port);
//OutputStream output = socket.getOutputStream();
Scanner scan = new Scanner(System.in);
String message=new String();
while(true){
Socket socket = new Socket(host, port);
OutputStream output = socket.getOutputStream();
System.out.println("输入信息");
message=scan.next();
output.write(message.getBytes("utf-8"));
socket.shutdownOutput();
BufferedReader input = new BufferedReader(new InputStreamReader(socket.getInputStream()));
String read = input.readLine();
System.out.println("服务器的内容 " +read);
input.close();
if(message.equals("end")) break;
}
//message="1/4+1/3";
//output.write(message.getBytes("utf-8"));
//正常来说，客户端打开一个输出流，如果不做约定，也不关闭它，那么服务端永远不知道客户端是否发送完消息，
//那么服务端会一直等待下去，直到读取超时。所以怎么告知服务端已经发送完消息就显得特别重要。
//socket.close();
//Socket关闭的时候，服务端就会收到响应的关闭信号，那么服务端也就知道流已经关闭了，这个时候读取操作完成，就可以继续后续工作
}
}
package myRocket;
import java.io.*;
import java.net.*;
import java.util.Scanner;
public class 服务器初步尝试 {
public static void main(String[] args) throws Exception{
//指定监听的端口
int myport = 8080;
ServerSocket myserver = new ServerSocket(myport,1);
//等待连接的到来
//System.out.println("server将一直等待连接的到来");
//Socket socket = myserver.accept();
//accept 侦听并接受到此套接字的连接。此方法在连接传入之前一直阻塞。
//即 服务器调用 accept() 方法，该方法将一直等待直到客户端连接到服务器上给定的端口。.
// 读取客户端数据
//BufferedReader input = new BufferedReader(new InputStreamReader(socket.getInputStream()));
String clientInputStr =new String();
while(true) {
//等待连接的到来
System.out.println("server将一直等待连接的到来");
Socket socket = myserver.accept();
BufferedReader input = new BufferedReader(new InputStreamReader(socket.getInputStream()));
clientInputStr = input.readLine();
/*Scanner scan = new Scanner(socket.getInputStream());
clientInputStr = scan.next();//这也是一种方法*/
System.out.println("客户端发过来的内容:" + clientInputStr);
if(clientInputStr.equals("end")) {input.close();break;}
OutputStream output = socket.getOutputStream();
output.write(复数计算/*有理数计算尝试*/.计算(clientInputStr).getBytes());
input.close();
output.close();
}
//public InputStream getInputStream()throws IOException返回此套接字的输入流。
//------------------------------------
// public BufferedReader(Reader in) :创建一个使用默认大小输入缓冲区的缓冲字符输入流。
//InputStreamReader 是字节流通向字符流的桥梁：它使用指定的 charset ***读取字节并将其解码为字符*** 。它使用的字符集可以由名称指定或显式给定，或者可以接受平台默认的字符集。
//每次调用 InputStreamReader 中的一个 read() 方法都会导致从底层输入流读取一个或多个字节。要启用从字节到字符的有效转换，可以提前从底层流读取更多的字节，使其超过满足当前读取操作所需的字节。
//为了达到最高效率，可要考虑在 BufferedReader 内包装 InputStreamReader。例如：
// BufferedReader in
// = new BufferedReader(new InputStreamReader(System.in));
//字节流->字符流->字符流缓冲区
//-----------------------------------
//String clientInputStr = input.readLine();//这里要注意和客户端输出流的写方法对应,否则会抛 EOFException
// 处理客户端数据
//System.out.println("客户端发过来的内容:" + clientInputStr);
//有理数计算尝试.计算(clientInputStr);
//input.close();
//socket.close();
myserver.close();
}
}
3.实验过程中遇到的问题和解决过程
- 问题1：有理数计算器的最小公倍数与最大公约数算法
- 问题1解决方案：找到网上代码和博客学长学姐代码，研读算法
- 问题2：远程计算器分配参数、识别运算符号
- 问题2解决方案：参考同学代码运算方式，网上查找陌生关键词
其他（感悟、思考等）
在这次实验过程中，我遇到了许多问题，其中既有知识上的漏洞，也有不细心导致的马虎，这一切都补充，完善，丰富，扩展了我的计算机知识体系。在这个过程中，我还进一步熟悉了IDEA这个平台的使用与运行方式，提高了自己自主学习的能力，为我接下来学习数据结构以及JAVA语言程序设计打下了坚实的基础，并在不断探索的过程中逐步提升了自己。
