20202324 实验四 《数据结构与面向对象程序设计》实验报告

# 20202324 2021-2022-1 《数据结构与面向对象程序设计》实验报告

课程：《程序设计与数据结构》
班级： 2023
姓名：肖郅宇
学号：202023124
实验教师：王志强
实验日期：2021年10月12日
必修/选修： 必修

 

## 1.实验内容

（一）Java Socket编程

1.学习蓝墨云上教材《Java和Android编程》“第16章 输入/输出 ”和“第22章 网络”，学习JavaSocket编程
2.结对编程。结对伙伴A编写客户端SocketClient.java，结对伙伴B编写服务器端。
3.截图加学号水印上传蓝墨云，代码push到码云，并撰写实验报告。

（二）Java和密码学

参考 http://www.cnblogs.com/rocedu/p/6683948.html

以结对的方式完成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码云。

 

## 2.实验过程及结果

（一）Java Socket编程

①服务器端

 

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
public class Servertest {
 public static void main(String[] args) throws IOException {
 //1.建立一个服务器Socket(ServerSocket)绑定指定端口
 ServerSocket serverSocket=new ServerSocket(2324);
 //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("The Server has been established！");
 while(!((info = bufferedReader.readLine()) ==null)){
 System.out.println("你猜猜我想说什么：" + info);
 }
 //给客户一个响应
 String reply="WUHUFLY!!!";
 printWriter.write(reply);
 printWriter.flush();
 //5.关闭资源
 printWriter.close();
 outputStream.close();
 bufferedReader.close();
 inputStream.close();
 socket.close();
 serverSocket.close();
 }
}

 

②客户端

 

import java.io.*;
import java.net.Socket;
public class SocketClient {
 public static void main(String[] args) throws IOException {
 //1.建立客户端Socket连接，指定服务器位置和端口
 Socket socket = new Socket("172.16.43.44",2324);
 //2.得到socket读写流
 OutputStream outputStream = socket.getOutputStream();
 PrintWriter printWriter = new PrintWriter(outputStream);
 OutputStreamWriter outputStreamWriter = new OutputStreamWriter(outputStream);
 //输入流
 InputStream inputStream = socket.getInputStream();
 BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream,"GBK"));
 //3.利用流按照一定的操作，对socket进行读写操作
 String info1 = " 用户名：Dogxzy，密码：iamdog";
 String info = new String(info1.getBytes("GBK"),"GBK");
 printWriter.write(info);
 printWriter.flush();
 outputStreamWriter.write(info1);
 outputStreamWriter.flush();
 socket.shutdownOutput();
 //接收服务器的响应
 String reply = null;
 while (!((reply = bufferedReader.readLine()) ==null)){
 System.out.println("接收服务器的信息为：" + reply);
 }
 //4.关闭资源
 bufferedReader.close();
 inputStream.close();
 outputStreamWriter.close();
 //printWriter.close();
 outputStream.close();
 socket.close();
 }
}


实验成果截图

 

 

 

 

 

 （三）编写有理数/复数计算器

 实验代码

 复数类
import java.util.Scanner;
public class Plural extends Calculate{
    public static void main(String[] args) {
        String next = "y";
        String s;
        do{
            Scanner scan = new Scanner(System.in);
            System.out.println("请输入复数运算式，各符号数字间用空格隔开，负数除外（如：( 1 + 2 i ) + ( 2 + -3 i ) ）：");
            Calculate ff;
            ff = new Plural();
            s = scan.nextLine();
            ff.Faction(s);

            Calculate count;
            count = new Plural();

            switch (ch){
                case '+':
                {
                    count.Add();
                    break;
                }
                case '-':
                {
                    count.Sub();
                    break;
                }
                case '*':
                {
                    count.Mul();
                    break;
                }
                case '/':
                {
                    count.Div();
                    break;
                }
                default:
                    System.out.println("Illegal input!");
                    break;
            }

            System.out.println(count.toString(s));

            System.out.print("如果您想要继续计算，请输入y，否则输入其他: ");
            choose = scan.nextLine();
        }while(choose.equals(next));
    }
}


分数类



import java.util.StringTokenizer;
public class fenshu {
    int fenzi,fenmu;
    char ch;

    public fenshu(String str) {
        StringTokenizer st=new StringTokenizer(str,"/",true);
        this.fenzi = Integer.parseInt(st.nextToken());
        this.ch=st.nextToken().charAt(0);
        this.fenmu = Integer.parseInt(st.nextToken());
    }

    public fenshu yuefen(int fz,int fm){
        int i;

        for (i=2;i<=fz&&i<=fm;i++){
            if(fz%i==0&&fm%i==0){
                fz=fz/i;
                fm=fm/i;
            }
        }

        fenshu result=new fenshu(fz+"/"+fm);
        return result;
    }

    public fenshu getJia(fenshu x){
        int newFenmu=this.fenmu*x.fenmu;
        int newFenzi=fenzi*x.fenmu+x.fenzi*fenmu;
        return yuefen(newFenzi,newFenmu);
    }

    public fenshu getJian(fenshu x){
        int newFenmu=fenmu*x.fenmu;
        int newFenzi=fenzi*x.fenmu-x.fenzi*fenmu;
        return yuefen(newFenzi,newFenmu);
    }

    public fenshu getCheng(fenshu x){
        int newFenmu=fenmu*x.fenmu;
        int newFenzi=fenzi*x.fenzi;
        return yuefen(newFenzi,newFenmu);
    }

    public fenshu getChu(fenshu x){
        int newFenmu=fenmu*x.fenzi;
        int newFenzi=fenzi*x.fenmu;
        return yuefen(newFenzi,newFenmu);
    }

    @Override
    public String toString() {
        return fenzi + "/" + fenmu;
    }

}

有理数计算器
public class RationalNumberCalculator {
    public static void main(String[] args) {

        fenshu result;
        fenshu fenshu1;
        if(args[0].contains("/")){
            fenshu1=new fenshu(args[0]);
        }
        else{
            fenshu1=new fenshu(args[0]+"/"+1);
        }

        fenshu fenshu2;
        if(args[2].contains("/")){
            fenshu2=new fenshu(args[2]);
        }
        else{
            fenshu2=new fenshu(args[2]+"/"+1);
        }

        char ch=args[1].charAt(0);


        switch (ch)
        {
            case '+':
                result=fenshu1.getJia(fenshu2);
                System.out.println(fenshu1+String.valueOf(ch)+fenshu2+"="+result);
                break;
            case '-':
                result=fenshu1.getJian(fenshu2);
                System.out.println(fenshu1+String.valueOf(ch)+fenshu2+"="+result);
                break;
            case '*':
                result=fenshu1.getCheng(fenshu2);
                System.out.println(fenshu1+String.valueOf(ch)+fenshu2+"="+result);
                break;
            case '/':
                result=fenshu1.getChu(fenshu2);
                System.out.println(fenshu1+String.valueOf(ch)+fenshu2+"="+result);
                break;
            default:
                System.out.println("Illegal input!");
                break;
        }
    }
}


复数计算器


import java.util.StringTokenizer;

public abstract class Calculate {
    static double a,b,c,d;
    double RealPart;
    double ImagePart;
    static String choose;
    public static char ch;

    public void Add() {
        RealPart = a + c;
        ImagePart = b + d;
    }

    public void Sub() {
        RealPart = a - c;
        ImagePart = b - d;
    }

    public void Mul() {
        RealPart = a*c - b*d;
        ImagePart = b*c + a*d;
    }

    public void Div() {
        RealPart = (a*c + b*d)/(c*c + d*d);
        ImagePart = (b*c + a*d)/(c*c + d*d);
    }

    public String toString(String s) {
        if(ImagePart >= 0){
            return s + "=" + RealPart + "+" + ImagePart + "i";
        }else {
            return s + "=" + RealPart +""+ ImagePart + "i";
        }
    }

    public void Faction(String f){
        char z;                                //取出不用于计算的符号
        StringTokenizer st = new StringTokenizer(f, " ", false);
        z = st.nextToken().charAt(0);
        a = Double.parseDouble(st.nextToken());
        z = st.nextToken().charAt(0);
        b = Double.parseDouble(st.nextToken());
        z = st.nextToken().charAt(0);
        z = st.nextToken().charAt(0);
        ch = st.nextToken().charAt(0);
        z = st.nextToken().charAt(0);
        c = Double.parseDouble(st.nextToken());
        z = st.nextToken().charAt(0);
        d = Double.parseDouble(st.nextToken());
    }
}

（四）远程有理数计算器

 实验代码

①服务器端

import java.io.*;
import java.net.ServerSocket;
import java.net.*;
import java.util.StringTokenizer;
public class server2 {
 private static fenshu frac2;
 private static fenshu frac1;
 private static String a,b;
 private static char ch;
 private static fenshu result = null;

 public static void main(String[] args) throws IOException {
 //1.建立一个服务器Socket(ServerSocket)绑定指定端口
 ServerSocket serverSocket=new ServerSocket(2324);
 //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("The server has been Established by xzy or wxy");
 while(!((info = bufferedReader.readLine()) ==null)){
 System.out.println("猜猜我要说什么，用户的加密信息为:"+ info);
 String s= info;
 String es="";
 int key = -4;
 for(int i=0;i<s.length( );i++)
 { char c=s.charAt(i);
 if(c>=0 && c<=127) // 是小写字母
 { c+=key%26; //移动key%26位
 if(c<0) c+=127; //向左超界
 if(c>127) c-=127; //向右超界
 }

 es+=c;
 }

 System.out.println("没想到吧，用户的解密后的信息竟然是：" + es);
 StringTokenizer st = new StringTokenizer(es, " ", false);
 a=st.nextToken();
 ch=st.nextToken().charAt(0);
 b=st.nextToken();
 frac1=new fenshu(a);
 frac2=new fenshu(b);

 switch (ch)
 {
 case '+':
 result=frac1.getJia(frac2);

 break;
 case '-':
 result=frac1.getJian(frac2);

 break;
 case '*':
 result=frac1.getCheng(frac2);

 break;
 case '/':
 result=frac1.getChu(frac2);

 break;
 default:

 break;
 }
 }
 //给客户一个响应
 String reply=frac1+String.valueOf(ch)+frac2+"="+result;
 String z= reply;
 String tes="";
 int key = 4;
 for(int j=0;j<z.length( );j++)
 { char d=z.charAt(j);
 if(d>=0 && d<=127) // 是小写字母
 { d+=key%26; //移动key%26位
 if(d<0) d+=127; //向左超界
 if(d>127) d-=127; //向右超界
 }

 tes+=d;
 }
 printWriter.write(tes);
 printWriter.flush();
 //5.关闭资源
 printWriter.close();
 outputStream.close();
 bufferedReader.close();
 inputStream.close();
 socket.close();
 serverSocket.close();
 }
}

②客户端

import java.io.*;
import java.net.*;
public class client2 {
 public static void main(String[] args) throws IOException {
 //1.建立客户端Socket连接，指定服务器位置和端口
 Socket socket = new Socket("172.20.10.8",2324);
// Socket socket = new Socket("172.16.43.187",8800);

 //2.得到socket读写流
 OutputStream outputStream = socket.getOutputStream();
 // PrintWriter printWriter = new PrintWriter(outputStream);
 OutputStreamWriter outputStreamWriter = new OutputStreamWriter(outputStream);
 //输入流
 InputStream inputStream = socket.getInputStream();
 BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream,"UTF-8"));
 //3.利用流按照一定的操作，对socket进行读写操作
 String info1 = " 1/4 + 1/6";
 String z= info1;
 String tes="";
 int key = 4;
 for(int j=0;j<z.length( );j++)
 { char d=z.charAt(j);
 if(d>=0 && d<=127) // 是小写字母
 { d+=key%26; //移动key%26位
 if(d<0) d+=127; //向左超界
 if(d>127) d-=127; //向右超界
 }

 tes+=d;
 }
 // String info = new String(info1.getBytes("GBK"),"utf-8");
 // printWriter.write(info);
 // printWriter.flush();
 outputStreamWriter.write(tes);
 outputStreamWriter.flush();
 socket.shutdownOutput();
 //接收服务器的响应
 String reply = null;
 while (!((reply = bufferedReader.readLine()) ==null)){
 System.out.println("接收到的服务器信息居然是"+ reply);
 String s= reply;
 String es="";
 key = -4;
 for(int i=0;i<s.length( );i++)
 { char c=s.charAt(i);
 if(c>=0 && c<=127) // 是小写字母
 { c+=key%26; //移动key%26位
 if(c<0) c+=127; //向左超界
 if(c>127) c-=127; //向右超界
 }

 es+=c;
 }
 System.out.println("结果最后接收服务器的信息明文为：" + es);
 }
 //4.关闭资源
 bufferedReader.close();
 inputStream.close();
 outputStreamWriter.close();
 //printWriter.close();
 outputStream.close();
 socket.close();
 }
}

实验成果截图

 

 

 

 

（五）远程复数计算器
 
实验代码

①服务器端

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

public class serverComplex extends Calculate{
 public static void main(String[] args) throws IOException {
 //建立服务器绑定窗口
 ServerSocket serverSocket = new ServerSocket(2324);
 //accept()方法处理连接请求，防止非法监听
 Socket socket = serverSocket.accept();
 //输入流
 InputStream inputStream = socket.getInputStream();
 BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
 //输出流
 OutputStream outputStream = socket.getOutputStream();
 PrintWriter printWriter = new PrintWriter(outputStream);
 //读取用户信息
 String info = null;
 System.out.println("The server is working...");
 //反馈信息
 while (!((info=bufferedReader.readLine())==null)) {
 System.out.println("我是超级xzy，接受的加密信息为：" + info);
 int key = -4; //取命令行参数的第二个字符，即密钥，并将其转为整型
 String es = ""; //创建接收密文的字符串变量并初始化
 for (int i = 0; i < info.length(); i++) { //逐一对明文字符进行加密
 char c = info.charAt(i);
 if (c >= 'a' && c <= 'z') // 是小写字母
 {
 c += key % 26; //移动key%26位
 if (c < 'a') c += 26; //向左超界
 if (c > 'z') c -= 26; //向右超界
 } else if (c >= '0' && c <= '9') // 是数字
 {
 c += key % 10;
 if (c < '0') c += 10;
 if (c > '9') c -= 10;
 } else if (c >= '*' && c <= '/') {
 c += key % 6;
 if (c < '*') c += 6;
 if (c > '/') c -= 6;
 }
 es += c;
 }
 System.out.println("笑死我了解密后的信息为：" + es);

 Calculate ff;
 ff = new serverComplex();
 ff.Faction(es);

 Calculate count;
 count = new serverComplex();

 switch (ch){case '+':
 {
 count.Add();
 break;
 }
 case '-':
 {
 count.Sub();
 break;
 }
 case '*':
 {
 count.Mul();
 break;
 }
 case '/':
 {
 count.Div();
 break;
 }
 }

 String reply = count.toString(es);

 //传递信息
 printWriter.write(reply);
 printWriter.flush();
 //关闭资源
 inputStream.close();
 outputStream.close();
 bufferedReader.close();
 printWriter.close();
 serverSocket.close();
 socket.close();
 }
 }
}

②客户端

import java.io.*;
import java.net.Socket;

public class ClientComplex {
 public static void main(String[] args) throws IOException {
 //建立客户端,host为伙伴的IP地址
 Socket socket = new Socket("172.20.10.8",2324);
 //输入流
 InputStream inputStream = socket.getInputStream();
 BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream,"GBK"));
 //输出流，获取socket读写流
 OutputStream outputStream = socket.getOutputStream();
 OutputStreamWriter outputStreamWriter = new OutputStreamWriter(outputStream);
 //利用流按照一定的操作，传递信息，对socket进行读写操作
 String s= "( 1 + 2 i ) + ( 1 + -2 i )"; //取命令行参数的第一个字符，即需要加密的明文
 int key=4; //取命令行参数的第二个字符，即密钥，并将其转为整型
 String es=""; //创建接收密文的字符串变量并初始化
 for(int i=0;i<s.length( );i++){ //逐一对明文字符进行加密
 char c=s.charAt(i);
 if(c>='a' && c<='z') // 是小写字母
 {
 c+=key%26; //移动key%26位
 if(c<'a') c+=26; //向左超界
 if(c>'z') c-=26; //向右超界
 }
 else if(c>='0' && c<='9') // 是数字
 {
 c+=key%10;
 if(c<'0') c+=10;
 if(c>'9') c-=10;
 }
 else if(c>='*' && c<='/')
 {
 c+=key%6;
 if(c<'*') c+=6;
 if(c>'/') c-=6;
 }
 es+=c;
 }

 System.out.println(es);
 String info1 = es;
 outputStreamWriter.write(info1);
 outputStreamWriter.flush();
 socket.shutdownOutput();
 //接受响应
 String reply = null;
 while (!((reply = bufferedReader.readLine())==null)){
 System.out.println(reply);
 }
 //关闭资源
 bufferedReader.close();
 inputStream.close();
 outputStreamWriter.close();
 outputStream.close();
 }
}

实验成果截图

 

 

 

 

 

 

## 3. 实验过程中遇到的问题和解决过程

- 问题1：服务器启动后客户端无法连接
- 问题1解决方案：各种方法搞定，接口、ip、校园网不行换成手机热点等等
- 问题2：输出的文字都是乱码
- 问题2解决方案：切换为GBK后解决，

 

 

## 其他（感悟、思考等）
太难了，不想再搞这么难的实验了。。。

 

不过还好每一个问题解决的时间都不长，只是代码量大到惊人而已，而已。

密码学的那个实在是搞不懂，就这样下班吧。

 

 

 希望下一个实验简单点。