• 实验四


    学号 2019-2020-182321 《数据结构与面向对象程序设计》实验四报告

    课程:《程序设计与数据结构》

    班级: 1823

    姓名: 杨凯涵

    学号:20182321

    实验教师:王志强

    实验日期:2019年10月7日

    必修/选修: 必修

    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编写复数计算器
    • 实验四:远程有理数计算器,结对编程,结对伙伴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实验过程及结果

    实验一

    学习javasocket编程,并与结对小伙伴一个实现服务端,一个实现客户端。


    通过以上的学习,我们知道,socket无外乎就是一个借口,SSocket就像是发动机,提供了网络通信的能力。由此,我们利用老师给我们的代码
    服务器:

    package HttpSocket;
    
    import java.io.*;
    import java.net.ServerSocket;
    import java.net.Socket;
    
    /**
     * Created by besti on 2019/9/29.
     */
    public class Server1823 {
        public static void main(String[] args) throws IOException {
            //1.建立一个服务器Socket(ServerSocket)绑定指定端口
            ServerSocket serverSocket=new ServerSocket(8800);
            //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();
        }
    }
    
    

    客户端:

    package HttpSocket;
    
    import com.sun.corba.se.impl.orbutil.ObjectUtility;
    
    import java.io.*;
    import java.net.Socket;
    
    /**
     * Created by besti on 2018/6/9.
     */
    public class SocketClient {
        public static void main(String[] args) throws IOException {
            //1.建立客户端Socket连接,指定服务器位置和端口
            Socket socket = new Socket("localhost",8800);
    //        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 = " 用户名:Tom,密码:123456";
    //        String info = new String(info1.getBytes("GBK"),"utf-8");
       //     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();
        }
    }
    
    

    在读取用户信息之前,我们是要建立一个接口,绑定一个端口,并且创建输出流和输入流的对象,这样两个程序之间的连接就算是做好了,接着作为服务器,就要从客户端出接受信息,这里用bufferedReader.readLine()来进行获取,而客户端是用outputStreamWriter.write来进行输出(这两个输入输出的对象在此之前已经建立),往下走,服务器再返回客户端一个信息(使用printWriter.write()),而客户端接受信息后就显示出来,最后再关闭我们的客户端和服务器。(运行结果中的乱码只需要把UTF-8挑为GBK就好了)。

    实验二

    Java和密码学:
    根据楼老师的博客操作:

    1. 凯撒密码:先约定好将明文往后移动多少个字母,然后对明文进行加密。如:YKH加密后为AOJ。我们的代码如下
    public static void main(String args[]) throws Exception{
    String s=args[0];
            int key=Integer.parseInt(args[1]);
            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>='A' && c<='Z') // 是大写字母
    {  c+=key%26;
                        if(c<'A') c+=26;
                        if(c>'Z') c-=26;
                      }
                   es+=c;
               }
           System.out.println(es);
         }
    

    运行截图:

    在这个地方输入我们要加密的内容,然后往后移动四位的意思。

    1. Java对称加密-DES算法
      运行截图:
      运行DES程序,得到密钥key1.dat

    保存密钥编码格式,在程序中输入java Skey_kb,在程序的当前目录中将产生文件名为keykb1.dat的文件,运行结果如下:

    处理加密结果:

    最终进行解密:

    1. Java非对称加密-RSA算法:
      在凯撒密码里提到的老地方输入java Skey_RSA,运行RSA从而生成公钥和私钥。

    继续输入java Skey_RSA,运行Enc RsA程序,得到如下结果:![]

    这都显示了公钥中的参数以及加密的结果c。

    接着运行程序输入java Dec_RSA运行DecRsa程序,得到如下结果:
    其中显示了私钥中的参数以及解密的结果,其中整型的明文转换后显示出字符串“Hello World!”。

    1. 使用密钥协定创建共享密钥
      建立A、B两个文件夹,然后分别在里面输入“java Key_DH Apub.dat Apri.dat”和“java Key_DH Bpub.dat Bpri.dat”运行,运行结果如图所示:

    将程序KeyAgree编译后分别拷贝在A和B两个目录,首先在A目录输入“java KeyAgree Bpub.dat Apri.dat”运行程序,它使用文件Bpub.dat中对方的公钥和文件Apri.dat中自己的私钥创建了一段共享的字节数组。

    实验三

    根据要求,我编写了一个计算器如图:

    实验四

    编写远程有理数计算器,我们编写了两个类,一个rational类,一个script类,rational用来进行有理数计算,而script用来讲客户输入的字符串转换成double输入到rational中。以下为代码

    rational.java
    package com.company;
    
    public class Rational {
        private int numerator ,denominator;
        public Rational(int numer,int denom)
        {
            if(denom == 0)
                denom = 1;
            if(denom < 0)
            {
                numer = numer * -1;
                denom = denom * -1;
            }
            numerator = numer;
            denominator = denom;
            reduce();
        }
    
    
    public int getNumerator()
    {
        return numerator;
    }
    public int getDemoninator()
    {
        return denominator;
    }
    public Rational reciprocal()
    {
        return new Rational(denominator,numerator);
    }
    public  Rational add (Rational op2)
    {
        int commonDenominator = denominator*op2.getDemoninator();
        int numerator1 = numerator*op2.getDemoninator();
        int numerator2 = op2.getNumerator()*denominator;
        int sum = numerator1 + numerator2;
        return new Rational(sum,commonDenominator);
    }
    public Rational subtract (Rational op2)
    {
        int commonDenominator = denominator*op2.getDemoninator();
        int numerator1 = numerator*op2.getDemoninator();
        int numerator2 = op2.getNumerator()*denominator;
        int difference = numerator1 - numerator2;
        return  new Rational(difference,commonDenominator);
    }
    public Rational multipy(Rational op2)
    {
        int numer = numerator* op2.getNumerator();
        int denom = denominator*op2.getDemoninator();
        return new Rational(numer,denom);
    }
    public Rational divide (Rational op2)
    {
        return multipy(op2.reciprocal());
    }
    public String toString()
    {
        String result;
        if (numerator == 0)
        {
            result = "0";
        }
        else
            if(denominator == 1)
            {
                result = numerator + "";
            }
            else
                result = numerator +"/"+denominator;
            return result;
    }
    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;
    }
    }
    
    package com.company;
    public class script
    {
        private String s ;
        public script(String s)
        {
            this.s=s;
        }
    public  String getresult()
    {
        String[] a1 = s.split("\*|\+|-|/");
    
        String reply = "";
        int a, b, c, d;
        a = Integer.parseInt(a1[0]);
        b = Integer.parseInt(a1[1]);
        c = Integer.parseInt(a1[2]);
        d = Integer.parseInt(a1[3]);
        Rational rational = new Rational(a,b );
        Rational rational1 = new Rational(c,d);
        int i = 0;
        int n = 0;
        char[] e = s.toCharArray();
        for (i = 0; i < e.length; i++) {
            if (e[i] == '+') {
                reply = rational.add(rational1).toString();
            } else if (e[i] == '-') {
                reply = rational.subtract(rational1).toString();
            } else if (e[i] == '*') {
                reply = rational.multipy(rational1).toString();
            } else if (e[i]=='/')
            {
                n++;
            }
            else if (e[i]=='/'||n==3)
            {
                reply = rational.divide(rational1).toString();
            }
        }
        return  reply;
    }
    }
    
    服务器
    package com.company;
    
    import java.io.*;
    import java.net.ServerSocket;
    import java.net.Socket;
    import javax.script.ScriptEngine;
    import javax.script.ScriptEngineManager;
    import javax.script.ScriptException;
    /**
     * Created by besti on 2019/9/29.
     */
    public class Server1823 {
        public static void main(String[] args) throws IOException, ScriptException {
            //1.建立一个服务器Socket(ServerSocket)绑定指定端口
            ServerSocket serverSocket=new ServerSocket(8800);
            //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("服务器已经建立......");
            info = bufferedReader.readLine();
            System.out.println("我是服务器,用户信息为:" + info);
            String reply = "";
            script s = new script(info);
            reply = s.getresult();
            printWriter.write(reply);
            printWriter.flush();
    
            //5.关闭资源
            printWriter.close();
            outputStream.close();
            bufferedReader.close();
            inputStream.close();
            socket.close();
            serverSocket.close();
        }
    }
    
    客户端
    package com.company;
    import java.io.*;
    import java.net.Socket;
    
    /**
     * Created by besti on 2018/6/9.
     */
    public class SocketClient {
        public static void main(String[] args) throws IOException {
            //1.建立客户端Socket连接,指定服务器位置和端口
            Socket socket = new Socket("192.168.43.229",8800);
    //        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/5";
    //        String info = new String(info1.getBytes("GBK"),"utf-8");
            //     printWriter.write(info);
            //     printWriter.flush();
            outputStreamWriter.write(info1);
            outputStreamWriter.flush();
            socket.shutdownOutput();
            //接收服务器的响应
            String reply = null;
            reply = bufferedReader.readLine();
            System.out.println("接收服务器的信息为:" + reply);
    
            //4.关闭资源
            bufferedReader.close();
            inputStream.close();
            outputStreamWriter.close();
            //printWriter.close();
            outputStream.close();
            socket.close();
        }
    }
    

    运行结果如图所示:

    实验五

    同实验四相同,我们编写了一个Complex类,一个hello类,前者用来计算复数,后者用来实现将用户的字符串转换成数字输入到complex中。两次实验我们都使用了slipt来对字符串进行分割。

    复数服务器
    package com.company;
    
    import java.io.*;
    import java.net.ServerSocket;
    import java.net.Socket;
    import javax.script.ScriptEngine;
    import javax.script.ScriptEngineManager;
    import javax.script.ScriptException;
    /**
     * Created by besti on 2019/9/29.
     */
    public class ServerComplex {
        public static void main(String[] args) throws IOException, ScriptException {
            //1.建立一个服务器Socket(ServerSocket)绑定指定端口
            ServerSocket serverSocket=new ServerSocket(8800);
            //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 info1=null;
            System.out.println("服务器已经建立......");
            info1 = bufferedReader.readLine();
            System.out.println("第一个复数为" + info1);
            String[] reply = info1.split("i");
            hello hi = new hello(reply[0]);
            hello hii = new hello(reply[1]);
            double a,b,c,d;
            a = hi.getrealpart();
            b = hi.getimagepart();
            c = hii.getrealpart();
            d = hii.getimagepart();
            char g = reply[2].charAt(0);
            Complex c1 =new Complex(a,b);
            Complex c2 =new Complex(c,d);
            String e="";
            if (g=='+')
            {
                e = c1.ComplexAdd(c2).toString();
            }
            else if(g=='-')
            {
                e = c1.ComplexSub(c2).toString();
            }
            else if(g=='*')
            {
                e = c1.ComplexMulti(c2).toString();
            }
            else if(g=='/')
            {
                e = c1.ComplexDiv(c2).toString();
            }
            printWriter.write(e);
            printWriter.flush();
    
            //5.关闭资源
            printWriter.close();
            outputStream.close();
            bufferedReader.close();
            inputStream.close();
            socket.close();
            serverSocket.close();
        }
    }
    
    复数客户端
    package com.company;
    import java.io.*;
    import java.net.Socket;
    import java.util.Scanner;
    /**
     * Created by besti on 2018/6/9.
     */
    public class SocketClient1823 {
        public static void main(String[] args) throws IOException {
            //1.建立客户端Socket连接,指定服务器位置和端口
            Socket socket = new Socket("192.168.43.174",8800);
    //        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 = "";
            Scanner scan = new Scanner(System.in);
            info1 = scan.nextLine();
            String info2 = "";
            info2 =scan.nextLine();
            String s = scan.next();
    //        String info = new String(info1.getBytes("GBK"),"utf-8");
            //     printWriter.write(info);
            //     printWriter.flush();
            outputStreamWriter.write(info1);
            outputStreamWriter.flush();
            outputStreamWriter.write(info2);
            outputStreamWriter.flush();
            outputStreamWriter.write(s);
            outputStreamWriter.flush();
            socket.shutdownOutput();
            //接收服务器的响应
            String reply = null;
            reply = bufferedReader.readLine();
            System.out.println("接收服务器的信息为:" + reply);
            //4.关闭资源
            bufferedReader.close();
            inputStream.close();
            outputStreamWriter.close();
            //printWriter.close();
            outputStream.close();
            socket.close();
        }
    }
    
    package com.company;
    
    import static java.lang.Character.*;
    
    public class hello
    {
    
        private int i=0;
        private double n=0;
        private int[] a = new int[2];
        private String x;
        public hello(String s)
        {
            x = s;
        }
    
           public double getrealpart()
           {
               String[] reply = x.split("\+|-|i");
               n = Integer.parseInt(reply[0]);
               return n;
           }
           public double getimagepart()
           {
               String[] reply1 = x.split("\+|-|i");
               n = Integer.parseInt(reply1[1]);
                       return n;
           }
    
    }
    
    package com.company;
    
    public class Complex{
        private double r;
        private double i;
    
        public Complex(double R, double I) {
            r = R;
            i = I;
        }
    
        public static double getRealPart(double r) {
            return r;
        }
    
        public static double getImagePart(double i) {
            return i;
        }
    
        public Complex ComplexAdd(Complex c) {
            return new Complex(r + c.r, i + c.i);
        }
        public Complex ComplexSub(Complex c) {
            return new Complex(r - c.r, i - c.i);
        }
        public Complex ComplexMulti(Complex c) {
            return new Complex(r * c.r - i * c.i, r * c.i + i * c.r);
        }
        public Complex ComplexDiv(Complex c) {
            return new Complex((r * c.i + i * c.r)/(c.i * c.i + c.r * c.r), (i * c.i + r * c.r)/(c.i * c.i + c.r * c.r));
        }
    
        public String toString() {
            String s = " ";
            if (i > 0)
                s =  r + "+" + i + "i";
            if (i == 0)
                s =  r + "";
            if (i < 0)
                s = r + " " + i + "i";
            return s;
        }
    }
    

    运行结果如图所示:

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

    • 问题1:出现connect reset问题。

    • 问题1解决方法:一开始连接不上的时候我们查阅了百度,可是发现始终没有有效的解决方法,于是我决定把编写的类给去掉,检查连接是否有问题。

    图片显示在没有类的情况下(里面的类是后面加上去的),并没有出现connect reset的问题,所以应该是类出现了问题。
    那么我编写了一个主程序aswd来运行试试看类,(因时间仓促没有截图)在运行过程中可以发现类里面的问题,并及时纠正,这样有助于快速找出程序问题的原因。

    (如图,我利用这个程序把自己写过的四个类都测试过,以此来找出程序中存在的问题)。

    • 问题2:split的使用问题
    • 问题2解决方法;split(“”)是将一个字符串一“”里的字符为标准,分成多个部分,如
    String s = "jdwlkaj-dwjakjwd";
    String[] a = s.split("-"); 
    

    那么,a[0]="jdwlkaj",a[1]="dwjakjwd",但是当我们在“”里放入+号时,系统却显示错误?原来+ * 不是有效的模式匹配规则表达式,用"" "+"转义后即可得到正确的结果。只需要改为split(“|+”)程序就可以运行了。

    其他(感悟、思考等)

    • 本次实验看起来对我们难度非常的大,其实内在是很简单明了的,有理数类的加减乘除和复数类的加减乘除的代码书上其实都有,而我们只需要理解清楚javasocket编程代码上的含义还有明白如何运用类将字符串转换成数字就好了,造成这次实验完成的不好在于对于书本的不重视。
    • 当程序运行出错的时候,其实可以将idea下方报错的名字信息复制粘贴到百度上来查询是为什么错了,这有利于我们自己发现问题,而不是有一点的问题都去询问助教。

    参考资料

    《Java程序设计与数据结构教程(第二版)》

    《Java程序设计与数据结构教程(第二版)》学习指导

  • 相关阅读:
    吴裕雄--天生自然 R语言开发学习:图形初阶
    吴裕雄--天生自然 R语言开发学习:导入数据
    如何基于阿里云搭建适合初创企业的轻量级架构?
    基于协同过滤算法的推荐
    重磅!阿里巴巴工程师获得 containerd 社区席位,与社区共建云时代容器标准
    完爆 Best Fit,看阿里如何优化 Sigma 在线调度策略节约亿级成本
    阿里云物联网边缘计算加载MQTT驱动
    阿里云物联网平台体验(树莓派+Python篇)
    RAM SSO功能重磅发布 —— 满足客户使用企业本地账号登录阿里云
    阿里云高级技术专家带你全面了解云主机性能评测
  • 原文地址:https://www.cnblogs.com/yangkaihan/p/11631458.html
Copyright © 2020-2023  润新知