20192307 2020-2021-1 《数据结构与面向对象程序设计》实验四报告

20192307 2020-2021-1-《数据结构与面向对象程序设计》实验四报告

  • 课程:《数据结构与面向对象程序设计》
  • 班级:1923班
  • 姓名:常万里
  • 学号:20192307
  • 任课教师: 王志强
  • 必修/选修:必修课

一、实验内容

  • (一)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码云。

二、实验过程及结果

(一)Java Socket编程

服务器端:

package ServerSocket;
/**
 * \* Created with IntelliJ IDEA.
 * \* User: Shape Of My Heart
 * \* Date: 2020/10/24
 * \* Time: 16:47
 * \* Besides,some of the best things in life are total mistakes.
 * \* Description:
 * \
 **/
import RSA.RSAEncrypt;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.charset.StandardCharsets;
import java.util.Scanner;

public class Server {
    /*
     * java.net.ServerSocket
     * 运行在服务端的ServerSocket主要有两个作用
     * 1:向系统申请服务端口,客户端就是通过这个端口与服务端建立连接的。
     *
     * 2:监听该端口,这样一旦一个客户端通过该端口尝试建立连接时,ServerSocket就会自动实例化
     *   一个Socket,那么通过这个Socket就可以与客户端对等并进行数据交互了。
     */
    private ServerSocket server;

    public Server() {
        try {
            /*
             * 实例化ServerSocket的同时要向系统
             * 申请服务端口,客户端就是通过这个端
             * 口与服务端建立连接的。
             */
            System.out.println("正在启动服务端...");
            server = new ServerSocket(8080);
            System.out.println("服务端启动完毕!");

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        Server server = new Server();
        server.start();
    }

    public void start() {
        try {
            /*
             * Socket accept()
             * ServerSocket的accept方法是一个阻塞
             * 方法,调用后会一直等待,直到一个客户端
             * 建立连接为止,此时该方法会返回一个Socket
             * 实例,通过这个Socket就可以与刚连接上的
             * 客户端进行数据交互了。
             * 多次调用accept可以等待不同客户端的连接
             */
            RSAEncrypt.genKeyPair();
            while (true) {
                System.out.println("等待客户端连接...");
                Socket socket = server.accept();
                System.out.println("一个客户端连接了!");

                /*
                 * 通过Socket获取输入流,可以读取到远端
                 * 计算机发送过来的字节。
                 */
                InputStream in = socket.getInputStream();
                InputStreamReader isr
                        = new InputStreamReader(in, StandardCharsets.UTF_8);
                BufferedReader br
                        = new BufferedReader(isr);

                Scanner scanner = new Scanner(System.in);
                OutputStream out = socket.getOutputStream();
                OutputStreamWriter osw = new OutputStreamWriter(out, StandardCharsets.UTF_8);
                BufferedWriter bw = new BufferedWriter(osw);
                PrintWriter pw = new PrintWriter(bw, true);

                String line = null;
                while ((line = br.readLine()) != null) {
                    System.out.println("客户端说:" + line);
                    String kEY2 = "MIICeAIBADANBgkqhkiG9w0BAQEFAASCAmIwggJeAgEAAoGBALwUtw1lbfBwY8WXmPZUBOvkvf3f/hnZFXQJqm1uCjYL8+1NjIDBCtTaEvvQpN/BBMq7jClU0QnrRkiQq8F4S68mmp8COUCTq7Bfh0W7KqTuwxk2JgDbPip0/6AfufgTN1kB1ADGSvvQW0nb9ZbgAa6ipOaDX+Gq/g22/fMqNCARAgMBAAECgYEAr8Q0JaLKkU6XDwtTebCfQMxt+Zmg4AsNj3mQ+d9CT6vv867rRVAijTSXVRlxW2II1mVa4S1QhZKIBjydJpsDLjlB8XnuzF6gazusXJCYW3/vFHNuQgaovOQ1EBI2Hta6k8yFzyl37rqIAOLQYpQs1VemlpHQ6nlWe0fCqvyotyECQQD3FZwENyP5w5sST7wxxcIyJAv2iO01CxovUjHcyxjNgmT3zy9q8VY5dWlomxp3N5TbZoq+RN+IKQh9yexiz8GFAkEAwt4Su+6KUzahvqS5AfIl46inzRDLXf5IOEsxwbuQaVJdYkQJD4xFxK5e3xJV734DMDNFxhgW7xtBmtHsA4qkHQJBAK8qPbHrWXDO0FfZ+SQb+8FKNsTva6LoHQchMUJDJXFEGMppskcRkrwnVbQYCVotKDWma4PaFdJUrLVoelHO0XUCQQCjhBdyTWMTGoe04qJACMJUe4R65fnQoHxXiHlzGIHAbxXfTDnSKyGsPalsRAWKVlI0kwGcjUBJWbS+RiJmgmLdAkB7MXkgJjxNLENiQbditwh15DyWIjocjhYaVvXj2QHWo+LXp7pEaEmLVTSJt4Q0lwzC2z4gbVp0AIfVQwDvSTp2\n";
                    String messageDe = RSAEncrypt.decrypt(line, kEY2);
                    System.out.println("解密后为:" + messageDe);
                    String line1 = scanner.nextLine();
                    String kEY1 = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQC8FLcNZW3wcGPFl5j2VATr5L393/4Z2RV0Captbgo2C/PtTYyAwQrU2hL70KTfwQTKu4wpVNEJ60ZIkKvBeEuvJpqfAjlAk6uwX4dFuyqk7sMZNiYA2z4qdP+gH7n4EzdZAdQAxkr70FtJ2/WW4AGuoqTmg1/hqv4Ntv3zKjQgEQIDAQAB";
                    String messageEn = RSAEncrypt.encrypt(line1, kEY1);
                    pw.println(messageEn);
                }

            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

客户端:

package ServerSocket;

/**
 * \* Created with IntelliJ IDEA.
 * \* User: Shape Of My Heart
 * \* Date: 2020/10/24
 * \* Time: 16:47
 * \* Besides,some of the best things in life are total mistakes.
 * \* Description:
 * \
 **/

import NBE2.Complex;
import RSA.RSAEncrypt;
import java.io.*;
import java.net.Socket;
import java.nio.charset.StandardCharsets;
import java.security.NoSuchAlgorithmException;
import java.util.Scanner;

public class Client {
    /*
     * java.net.Socket 套接字
     * 封装了TCP协议的通讯细节,使得我们可以通过它
     * 来与远端计算机建立TCP连接,并利用两个流的读写
     * 完成数据交互。
     */
    private Socket socket;

    {

    }

    /**
     * 构造方法,用来初始化客户端
     */
    public Client() {
        try {
            /*
             * Socket实例化是需要传入两个参数
             * 参数1:服务端IP地址
             * 参数2:服务端程序申请的端口
             * 我们通过IP可以找到网络上的服务端计算机
             * 通过端口可以连接到服务端计算机上运行的
             * 服务端应用程序了。
             * 注意:
             * 实例化Socket的过程就是连接的过程,若
             * 服务端没有响应这里会抛出异常。
             */
            System.out.println("正在连接服务端...");
            socket = new Socket("127.0.0.1", 8080);
            System.out.println("与服务端成功建立连接!");

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        Client client = new Client();
        client.start();
    }


    /**
     * 客户端开始工作的方法
     */
    public void start() {
        try {
            Scanner scanner = new Scanner(System.in);
            /*
             * Socket提供的方法:
             * OutputStream getOutputStream()
             * 该方法获取的输出流是一个字节输出流
             * 通过这个流写出的字节会通过网络发送
             * 到远端计算机上(对于客户端这边而言,
             * 远端计算机指的就是服务端了。)
             */

            InputStream in = null;
            try {
                in = socket.getInputStream();
            } catch (IOException e) {
                e.printStackTrace();
            }
            InputStreamReader isr
                    = null;
            isr = new InputStreamReader(in, StandardCharsets.UTF_8);
            BufferedReader br
                    = new BufferedReader(isr);
            OutputStream out = socket.getOutputStream();
            OutputStreamWriter osw = new OutputStreamWriter(out, StandardCharsets.UTF_8);
            BufferedWriter bw = new BufferedWriter(osw);
            PrintWriter pw = new PrintWriter(bw, true);
            RSAEncrypt.genKeyPair();
            String line2 = null;

            while (true) {
                String line = scanner.nextLine();
                String kEY1 = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQC8FLcNZW3wcGPFl5j2VATr5L393/4Z2RV0Captbgo2C/PtTYyAwQrU2hL70KTfwQTKu4wpVNEJ60ZIkKvBeEuvJpqfAjlAk6uwX4dFuyqk7sMZNiYA2z4qdP+gH7n4EzdZAdQAxkr70FtJ2/WW4AGuoqTmg1/hqv4Ntv3zKjQgEQIDAQAB";
                String messageEn = RSAEncrypt.encrypt(line, kEY1);
                pw.println(messageEn);
                try {
                    if (!((line2 = br.readLine()) != null)) {
                        break;
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
                System.out.println("服务端说:" + line2);
                String kEY2 = "MIICeAIBADANBgkqhkiG9w0BAQEFAASCAmIwggJeAgEAAoGBALwUtw1lbfBwY8WXmPZUBOvkvf3f/hnZFXQJqm1uCjYL8+1NjIDBCtTaEvvQpN/BBMq7jClU0QnrRkiQq8F4S68mmp8COUCTq7Bfh0W7KqTuwxk2JgDbPip0/6AfufgTN1kB1ADGSvvQW0nb9ZbgAa6ipOaDX+Gq/g22/fMqNCARAgMBAAECgYEAr8Q0JaLKkU6XDwtTebCfQMxt+Zmg4AsNj3mQ+d9CT6vv867rRVAijTSXVRlxW2II1mVa4S1QhZKIBjydJpsDLjlB8XnuzF6gazusXJCYW3/vFHNuQgaovOQ1EBI2Hta6k8yFzyl37rqIAOLQYpQs1VemlpHQ6nlWe0fCqvyotyECQQD3FZwENyP5w5sST7wxxcIyJAv2iO01CxovUjHcyxjNgmT3zy9q8VY5dWlomxp3N5TbZoq+RN+IKQh9yexiz8GFAkEAwt4Su+6KUzahvqS5AfIl46inzRDLXf5IOEsxwbuQaVJdYkQJD4xFxK5e3xJV734DMDNFxhgW7xtBmtHsA4qkHQJBAK8qPbHrWXDO0FfZ+SQb+8FKNsTva6LoHQchMUJDJXFEGMppskcRkrwnVbQYCVotKDWma4PaFdJUrLVoelHO0XUCQQCjhBdyTWMTGoe04qJACMJUe4R65fnQoHxXiHlzGIHAbxXfTDnSKyGsPalsRAWKVlI0kwGcjUBJWbS+RiJmgmLdAkB7MXkgJjxNLENiQbditwh15DyWIjocjhYaVvXj2QHWo+LXp7pEaEmLVTSJt4Q0lwzC2z4gbVp0AIfVQwDvSTp2\n";
                String messageDe = null;
                try {
                    messageDe = RSAEncrypt.decrypt(line2, kEY2);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                System.out.println("解密后为:" + messageDe);
            }
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}



运行结果截图


(二)Java和密码学

Caesar密码

package Cryptography.Caesar;
/**
 * \* Created with IntelliJ IDEA.
 * \* User: Shape Of My Heart
 * \* Date: 2020/10/23
 * \* Time: 21:44
 * \* Besides,some of the best things in life are total mistakes.
 * \* Description:
 * \
 **/
public class Caesar {
    public static void main(String[] args) throws Exception {
        String s = args[0];
        int key = Integer.parseInt(args[1]);
        StringBuilder es = new StringBuilder();

        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.append(c);
        }
        System.out.println(es);
    }
}

DES算法

package Cryptography.DES_algorithm;

/**
 * \* Created with IntelliJ IDEA.
 * \* User: Shape Of My Heart
 * \* Date: 2020/10/24
 * \* Time: 18:20
 * \* Besides,some of the best things in life are total mistakes.
 * \* Description:
 * \
 **/

import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import java.io.FileInputStream;

public class SDec {
    public static void main(String args[]) throws Exception {
        // 获取密文
        FileInputStream f = new FileInputStream("SEnc.dat");
        int num = f.available();
        byte[] ctext = new byte[num];
        f.read(ctext);
        // 获取密钥
        FileInputStream f2 = new FileInputStream("keykb1.dat");
        int num2 = f2.available();
        byte[] keykb = new byte[num2];
        f2.read(keykb);
        SecretKeySpec k = new SecretKeySpec(keykb, "DESede");
        // 解密
        Cipher cp = Cipher.getInstance("DESede");
        cp.init(Cipher.DECRYPT_MODE, k);
        byte[] ptext = cp.doFinal(ctext);
        // 显示明文
        String p = new String(ptext, "UTF8");
        System.out.println(p);
    }
}
package Cryptography.DES_algorithm;

/**
 * \* Created with IntelliJ IDEA.
 * \* User: Shape Of My Heart
 * \* Date: 2020/10/24
 * \* Time: 18:19
 * \* Besides,some of the best things in life are total mistakes.
 * \* Description:
 * \
 **/

import javax.crypto.Cipher;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.security.Key;

public class SEnc {
    public static void main(String args[]) throws Exception {
        String s = "Hello World!";
        FileInputStream f = new FileInputStream("key1.dat");
        ObjectInputStream b = new ObjectInputStream(f);
        Key k = (Key) b.readObject();
        Cipher cp = Cipher.getInstance("DESede");
        cp.init(Cipher.ENCRYPT_MODE, k);
        byte ptext[] = s.getBytes("UTF8");
        for (int i = 0; i < ptext.length; i++) {
            System.out.print(ptext[i] + ",");
        }
        System.out.println("");
        byte ctext[] = cp.doFinal(ptext);
        for (int i = 0; i < ctext.length; i++) {
            System.out.print(ctext[i] + ",");
        }
        FileOutputStream f2 = new FileOutputStream("SEnc.dat");
        f2.write(ctext);
    }
}
package Cryptography.DES_algorithm;

/**
 * \* Created with IntelliJ IDEA.
 * \* User: Shape Of My Heart
 * \* Date: 2020/10/24
 * \* Time: 18:16
 * \* Besides,some of the best things in life are total mistakes.
 * \* Description:
 * \
 **/

import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;

public class Skey_DES {
    public static void main(String args[])
            throws Exception {
        KeyGenerator kg = KeyGenerator.getInstance("DESede");
        kg.init(168);
        SecretKey k = kg.generateKey();
        FileOutputStream f = new FileOutputStream("key1.dat");
        ObjectOutputStream b = new ObjectOutputStream(f);
        b.writeObject(k);
    }
}
package Cryptography.DES_algorithm;

/**
 * \* Created with IntelliJ IDEA.
 * \* User: Shape Of My Heart
 * \* Date: 2020/10/24
 * \* Time: 18:17
 * \* Besides,some of the best things in life are total mistakes.
 * \* Description:
 * \
 **/

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.security.Key;

public class Skey_kb {
    public static void main(String[] args) throws Exception {
        FileInputStream f = new FileInputStream("key1.dat");
        ObjectInputStream b = new ObjectInputStream(f);
        Key k = (Key) b.readObject();
        byte[] kb = k.getEncoded();
        FileOutputStream f2 = new FileOutputStream("keykb1.dat");
        f2.write(kb);
        // 打印密钥编码中的内容
        for (int i = 0; i < kb.length; i++) {
            System.out.print(kb[i] + ",");
        }
    }
}

RSA算法

package Cryptography.RSA_algorithm;

/**
 * \* Created with IntelliJ IDEA.
 * \* User: Shape Of My Heart
 * \* Date: 2020/10/24
 * \* Time: 18:24
 * \* Besides,some of the best things in life are total mistakes.
 * \* Description:
 * \
 **/

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.io.ObjectInputStream;
import java.math.BigInteger;
import java.security.interfaces.RSAPrivateKey;
public class Dec_RSA{
    public static void main(String args[]) throws Exception{
        //读取密文
        BufferedReader in=
                new BufferedReader(new InputStreamReader(
                        new FileInputStream("Enc_RSA.dat")));
        String ctext=in.readLine();
        BigInteger c=new BigInteger(ctext);
        //读取私钥
        FileInputStream f=new FileInputStream("Skey_RSA_priv.dat");
        ObjectInputStream b=new ObjectInputStream(f);
        RSAPrivateKey prk=(RSAPrivateKey)b.readObject( );
        BigInteger d=prk.getPrivateExponent();
        //获取私钥参数及解密
        BigInteger n=prk.getModulus();
        System.out.println("d= "+d);
        System.out.println("n= "+n);
        BigInteger m=c.modPow(d,n);
        //显示解密结果
        System.out.println("m= " + m);
        byte[] mt=m.toByteArray();
        System.out.println("PlainText is ");
        for(int i=0;i<mt.length;i++){
            System.out.print((char) mt[i]);
        }
    }
}
package Cryptography.RSA_algorithm;

/**
 * \* Created with IntelliJ IDEA.
 * \* User: Shape Of My Heart
 * \* Date: 2020/10/24
 * \* Time: 18:30
 * \* Besides,some of the best things in life are total mistakes.
 * \* Description:
 * \
 **/

import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;

public class DigestPass {
    public static void main(String[] args) throws Exception {
        String x = args[0];
        MessageDigest m = MessageDigest.getInstance("MD5");
        m.update(x.getBytes(StandardCharsets.UTF_8));
        byte[] s = m.digest();
        StringBuilder result = new StringBuilder();
        for (int i = 0; i < s.length; i++) {
            result.append(Integer.toHexString((0x000000ff & s[i]) |
                    0xffffff00).substring(6));
        }
        System.out.println(result);
    }
}
import java.io.*;
import java.math.BigInteger;
import java.security.interfaces.RSAPublicKey;

public class Enc_RSA {
    public static void main(String args[]) throws Exception {
        String s = "Hello World!";
        // 获取公钥及参数e,n
        FileInputStream f = new FileInputStream("Skey_RSA_pub.dat");
        ObjectInputStream b = new ObjectInputStream(f);
        RSAPublicKey pbk = (RSAPublicKey) b.readObject();
        BigInteger e = pbk.getPublicExponent();
        BigInteger n = pbk.getModulus();
        System.out.println("e= " + e);
        System.out.println("n= " + n);
        // 明文 m
        byte ptext[] = s.getBytes("UTF8");
        BigInteger m = new BigInteger(ptext);
        // 计算密文c,打印
        BigInteger c = m.modPow(e, n);
        System.out.println("c= " + c);
        // 保存密文
        String cs = c.toString();
        BufferedWriter out =
                new BufferedWriter(new OutputStreamWriter(
                        new FileOutputStream("Enc_RSA.dat")));
        out.write(cs, 0, cs.length());
        out.close();

    }
}
public class Key_DH {
    //三个静态变量的定义从
// C:\j2sdk-1_4_0-doc\docs\guide\security\jce\JCERefGuide.html
// 拷贝而来
// The 1024 bit Diffie-Hellman modulus values used by SKIP
    private static final byte skip1024ModulusBytes[] = {
            (byte) 0xF4, (byte) 0x88, (byte) 0xFD, (byte) 0x58,
            (byte) 0x4E, (byte) 0x49, (byte) 0xDB, (byte) 0xCD,
            (byte) 0x20, (byte) 0xB4, (byte) 0x9D, (byte) 0xE4,
            (byte) 0x91, (byte) 0x07, (byte) 0x36, (byte) 0x6B,
            (byte) 0x33, (byte) 0x6C, (byte) 0x38, (byte) 0x0D,
            (byte) 0x45, (byte) 0x1D, (byte) 0x0F, (byte) 0x7C,
            (byte) 0x88, (byte) 0xB3, (byte) 0x1C, (byte) 0x7C,
            (byte) 0x5B, (byte) 0x2D, (byte) 0x8E, (byte) 0xF6,
            (byte) 0xF3, (byte) 0xC9, (byte) 0x23, (byte) 0xC0,
            (byte) 0x43, (byte) 0xF0, (byte) 0xA5, (byte) 0x5B,
            (byte) 0x18, (byte) 0x8D, (byte) 0x8E, (byte) 0xBB,
            (byte) 0x55, (byte) 0x8C, (byte) 0xB8, (byte) 0x5D,
            (byte) 0x38, (byte) 0xD3, (byte) 0x34, (byte) 0xFD,
            (byte) 0x7C, (byte) 0x17, (byte) 0x57, (byte) 0x43,
            (byte) 0xA3, (byte) 0x1D, (byte) 0x18, (byte) 0x6C,
            (byte) 0xDE, (byte) 0x33, (byte) 0x21, (byte) 0x2C,
            (byte) 0xB5, (byte) 0x2A, (byte) 0xFF, (byte) 0x3C,
            (byte) 0xE1, (byte) 0xB1, (byte) 0x29, (byte) 0x40,
            (byte) 0x18, (byte) 0x11, (byte) 0x8D, (byte) 0x7C,
            (byte) 0x84, (byte) 0xA7, (byte) 0x0A, (byte) 0x72,
            (byte) 0xD6, (byte) 0x86, (byte) 0xC4, (byte) 0x03,
            (byte) 0x19, (byte) 0xC8, (byte) 0x07, (byte) 0x29,
            (byte) 0x7A, (byte) 0xCA, (byte) 0x95, (byte) 0x0C,
            (byte) 0xD9, (byte) 0x96, (byte) 0x9F, (byte) 0xAB,
            (byte) 0xD0, (byte) 0x0A, (byte) 0x50, (byte) 0x9B,
            (byte) 0x02, (byte) 0x46, (byte) 0xD3, (byte) 0x08,
            (byte) 0x3D, (byte) 0x66, (byte) 0xA4, (byte) 0x5D,
            (byte) 0x41, (byte) 0x9F, (byte) 0x9C, (byte) 0x7C,
            (byte) 0xBD, (byte) 0x89, (byte) 0x4B, (byte) 0x22,
            (byte) 0x19, (byte) 0x26, (byte) 0xBA, (byte) 0xAB,
            (byte) 0xA2, (byte) 0x5E, (byte) 0xC3, (byte) 0x55,
            (byte) 0xE9, (byte) 0x2F, (byte) 0x78, (byte) 0xC7
    };
    // The SKIP 1024 bit modulus
    private static final BigInteger skip1024Modulus
            = new BigInteger(1, skip1024ModulusBytes);
    // The base used with the SKIP 1024 bit modulus
    private static final BigInteger skip1024Base = BigInteger.valueOf(2);

    public static void main(String args[]) throws Exception {
        DHParameterSpec DHP =
                new DHParameterSpec(skip1024Modulus, skip1024Base);

        KeyPairGenerator kpg = KeyPairGenerator.getInstance("DH");
        kpg.initialize(DHP);
        KeyPair kp = kpg.genKeyPair();

        PublicKey pbk = kp.getPublic();
        PrivateKey prk = kp.getPrivate();
        // 保存公钥
        FileOutputStream f1 = new FileOutputStream(args[0]);
        ObjectOutputStream b1 = new ObjectOutputStream(f1);
        b1.writeObject(pbk);
        // 保存私钥
        FileOutputStream f2 = new FileOutputStream(args[1]);
        ObjectOutputStream b2 = new ObjectOutputStream(f2);
        b2.writeObject(prk);
    }
}
public class KeyAgree {
    public static void main(String[] args) throws Exception {
        // 读取对方的DH公钥
        FileInputStream f1 = new FileInputStream(args[0]);
        ObjectInputStream b1 = new ObjectInputStream(f1);
        PublicKey pbk = (PublicKey) b1.readObject();
//读取自己的DH私钥
        FileInputStream f2 = new FileInputStream(args[1]);
        ObjectInputStream b2 = new ObjectInputStream(f2);
        PrivateKey prk = (PrivateKey) b2.readObject();
        // 执行密钥协定
        KeyAgreement ka = KeyAgreement.getInstance("DH");
        ka.init(prk);
        ka.doPhase(pbk, true);
        //生成共享信息
        byte[] sb = ka.generateSecret();
        for (byte b : sb) {
            System.out.print(b + ",");
        }
        SecretKeySpec k = new SecretKeySpec(sb, "DESede");
    }
}
public class Skey_RSA {
    public static void main(String args[]) throws Exception {
        KeyPairGenerator kpg = KeyPairGenerator.getInstance("RSA");
        kpg.initialize(1024);
        KeyPair kp = kpg.genKeyPair();
        PublicKey pbkey = kp.getPublic();
        PrivateKey prkey = kp.getPrivate();
        //  保存公钥
        FileOutputStream f1 = new FileOutputStream("Skey_RSA_pub.dat");
        ObjectOutputStream b1 = new ObjectOutputStream(f1);
        b1.writeObject(pbkey);
        //  保存私钥
        FileOutputStream f2 = new FileOutputStream("Skey_RSA_priv.dat");
        ObjectOutputStream b2 = new ObjectOutputStream(f2);
        b2.writeObject(prkey);
    }
}

运行结果截图



(三)编写复数计算器

复数计算类:

package NBE2;

/**
 * \* Created with IntelliJ IDEA.
 * \* User: Shape Of My Heart
 * \* Date: 2020/10/10
 * \* Time: 21:16
 * \* Besides,some of the best things in life are total mistakes.
 * \* Description:
 * \
 *
 * @author Shape Of My Heart
 */

public class Complex implements Operation {
    // 定义属性并生成getter,setter
    double RealPart;
    double ImagePart;
    private Object o;

    // 定义构造函数
    public Complex() {
        RealPart = 0;
        ImagePart = 1;
    }

    public double getRealPart() {
        return RealPart;
    }

    public void setRealPart(double realPart) {
        RealPart = realPart;
    }

    public double getImagePart() {
        return ImagePart;
    }

    public void setImagePart(double imagePart) {
        ImagePart = imagePart;
    }

    public Complex(double R, double I) {
        RealPart = R;
        ImagePart = I;
    }

    //Override Object
    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (!(obj instanceof Complex)) {
            return false;
        }
        Complex complex = (Complex) obj;
        if (complex.RealPart != ((Complex) obj).RealPart) {
            return false;
        }
        if (complex.ImagePart != ((Complex) obj).ImagePart) {
            return false;
        }

        return true;
    }

    @Override
    public String toString() {
        String string = "";
        if (ImagePart > 0) {
            string = RealPart + "+" + ImagePart + "i";
        }
        if (ImagePart == 0) {
            string = RealPart + "";
        }
        if (ImagePart < 0) {
            string = RealPart + " " + ImagePart + "i";
        }
        return string;
    }

    // 定义公有方法:加减乘除
    public Complex ComplexAdd(Complex a) {
        double b, c;
        b = RealPart + a.RealPart;
        c = ImagePart + a.ImagePart;
        System.out.println("(" + RealPart + "+" + ImagePart + "i) + (" + a.RealPart + "+" + a.ImagePart + ") = " + b + "+" + c + "i");
        return new Complex(b, c);
    }

    public Complex ComplexSub(Complex a) {
        double b, c;
        b = RealPart - a.RealPart;
        c = ImagePart - a.ImagePart;
        System.out.println("(" + RealPart + "+" + ImagePart + "i) - (" + a.RealPart + "+" + a.ImagePart + ") = " + b + "+" + c + "i");
        return new Complex(b, c);
    }

    public Complex ComplexMulti(Complex a) {
        double b, c;
        b = RealPart * a.RealPart - ImagePart * a.ImagePart;
        c = ImagePart * a.RealPart + RealPart * a.ImagePart;
        System.out.println("(" + RealPart + "i+" + ImagePart + "i) * (" + a.RealPart + "+" + a.ImagePart + "i) = " + b + "+" + c + "i");
        return new Complex(b, c);
    }

    public Complex ComplexDiv(Complex a) {
        if (a.RealPart == 0 || a.ImagePart == 0) {
            System.out.println("被除数不能为0,错误");
            return new Complex();
        }
        double b, c;
        b = (RealPart * a.RealPart + ImagePart * a.ImagePart) / (Math.pow(a.RealPart, 2) + Math.pow(a.ImagePart, 2));
        c = (ImagePart * a.RealPart - RealPart * a.ImagePart) / (Math.pow(a.RealPart, 2) + Math.pow(a.ImagePart, 2));
        System.out.println("(" + RealPart + "i+" + ImagePart + "i) / (" + a.RealPart + "+" + a.ImagePart + "i) = " + b + "+" + c + "i");
        return new Complex(b, c);

    }

    public int compareTo(Object o) {
        Complex temp = (Complex) o;
        if (temp.RealPart > this.RealPart) {
            return 1;
        } else {
            return 0;
        }
    }

    @Override
    public int carry() {
        return 0;
    }

    @Override
    public int carry(Complex temp) {
        if (temp.ImagePart > this.ImagePart) {
            return 1;
        } else {
            return 0;
        }
    }
}

计算器代码

package NBE2;

import java.util.Scanner;

/**
 * \* Created with IntelliJ IDEA.
 * \* User: Shape Of My Heart
 * \* Date: 2020/10/24
 * \* Time: 19:43
 * \* Besides,some of the best things in life are total mistakes.
 * \* Description:
 * \
 *
 * @author Shape Of My Heart
 */

public class complexCalculator extends Complex {
    public complexCalculator() {
    }

    public complexCalculator(double R, double I) {
        super(R, I);
    }


    public static double Calculator(double x, double y, int z) {


        return 0;
    }


    public static void main(String[] args) {
        System.out.println("   Welcome!This is a simple calculator.\n");
        for (; ; ) {
            System.out.println("What kind of operations do you want?");
            System.out.println("1.Addition");
            System.out.println("2.Subtraction");
            System.out.println("3.Multiplication");
            System.out.println("4.Division");
            System.out.println("5.Compare the size of the real part");
            System.out.println("6.Compare the size of imaginary part");
            System.out.println("7.Quit");
            Scanner input = new Scanner(System.in);
            int a = input.nextInt();
            if (a < 1 || a > 7) {
                System.out.println("error!please choose again");
            }
            if (a == 7) {
                break;
            }
            System.out.println("Please enter the real part and imaginary part of the first imaginary number");
            int x = input.nextInt();
            int y = input.nextInt();
            Complex complex1 = new Complex(x, y);
            System.out.println("Please enter the real part and imaginary part of the second imaginary number");
            x = input.nextInt();
            y = input.nextInt();
            Complex complex2 = new Complex(x, y);
            if (a == 1) {
                System.out.println(complex1.ComplexAdd(complex2));

            }
            if (a == 2) {
                System.out.println(complex1.ComplexSub(complex2));

            }
            if (a == 3) {
                System.out.println(complex1.ComplexMulti(complex2));

            }
            if (a == 4) {
                System.out.println(complex1.ComplexDiv(complex2));

            }
            if (a == 5) {
                if (complex1.compareTo(complex2) == 1) {
                    System.out.println("The real part of the second imaginary number is larger");
                } else {
                    System.out.println("The real part of the first imaginary number is larger");
                }
            }
            if (a == 6) {
                if (complex1.carry(complex2) == 1) {
                    System.out.println("The imaginary part of the second imaginary number is larger");
                } else {
                    System.out.println("The imaginary part of the first imaginary number is larger");
                }
            }
        }
    }
}

运行结果截图

(四)远程有理数计算器

package RationalNumberCalculator;

/**
 * \* Created with IntelliJ IDEA.
 * \* User: Shape Of My Heart
 * \* Date: 2020/10/27
 * \* Time: 21:29
 * \* Besides,some of the best things in life are total mistakes.
 * \* Description:
 * \
 **/

import java.util.StringTokenizer;

public class Fraction {
    int fenzi, fenmu;
    char ch;

    public Fraction(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 Fraction 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;
            }
        }

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

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

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

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

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

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

/**
 * \* Created with IntelliJ IDEA.
 * \* User: Shape Of My Heart
 * \* Date: 2020/10/27
 * \* Time: 21:28
 * \* Besides,some of the best things in life are total mistakes.
 * \* Description:
 * \
 **/

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

/**
 * Created by besti on 2019/9/29.
 */
public class Server1923 {

    private static Fraction frac2;
    private static Fraction frac1;
    private static String a,b;
    private static char ch;
    private static Fraction result = null;

    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);


            StringTokenizer st = new StringTokenizer(info, " ", false);
            a=st.nextToken();
            ch=st.nextToken().charAt(0);
            b=st.nextToken();
            frac1=new Fraction(a);
            frac2=new Fraction(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;
        printWriter.write(reply);
        printWriter.flush();
        //5.关闭资源
        printWriter.close();
        outputStream.close();
        bufferedReader.close();
        inputStream.close();
        socket.close();
        serverSocket.close();
}
}
package RationalNumberCalculator;

/**
 * \* Created with IntelliJ IDEA.
 * \* User: Shape Of My Heart
 * \* Date: 2020/10/27
 * \* Time: 21:27
 * \* Besides,some of the best things in life are total mistakes.
 * \* Description:
 * \
 **/

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

/**
 * Created by besti on 2018/6/9.
 */
public class SocketClient2 {
    public static void main(String[] args) throws IOException {
        //1.建立客户端Socket连接,指定服务器位置和端口
        Socket socket = new Socket("127.0.0.1", 8809);
//        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 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();
    }
}

运行结果截图


(五)远程复数计算器

服务器端:

package complexRemoteCalculator;

/*
  \* Created with IntelliJ IDEA.
  \* User: Shape Of My Heart
  \* Date: 2020/10/25
  \* Time: 16:21
  \* Besides,some of the best things in life are total mistakes.
  \* Description:
  \
import NBE2.Complex;
import RSA.RSAEncrypt;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.charset.StandardCharsets;
import java.util.Scanner;

public class calculatorServer {
    /*
     * java.net.ServerSocket
     * 运行在服务端的ServerSocket主要有两个作用
     * 1:向系统申请服务端口,客户端就是通过这个端口与服务端建立连接的。
     *
     * 2:监听该端口,这样一旦一个客户端通过该端口尝试建立连接时,ServerSocket就会自动实例化
     *   一个Socket,那么通过这个Socket就可以与客户端对等并进行数据交互了。
     */
    private ServerSocket server;

    public calculatorServer() {
        try {
            /*
             * 实例化ServerSocket的同时要向系统
             * 申请服务端口,客户端就是通过这个端
             * 口与服务端建立连接的。
             */
            System.out.println("正在启动服务端...");
            server = new ServerSocket(8080);
            System.out.println("服务端启动完毕!");

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        calculatorServer server1 = new calculatorServer();
        server1.start();
    }

    public void start() {
        try {
            /*
             * Socket accept()
             * ServerSocket的accept方法是一个阻塞
             * 方法,调用后会一直等待,直到一个客户端
             * 建立连接为止,此时该方法会返回一个Socket
             * 实例,通过这个Socket就可以与刚连接上的
             * 客户端进行数据交互了。
             * 多次调用accept可以等待不同客户端的连接
             */
            RSAEncrypt.genKeyPair();
            while (true) {
                System.out.println("等待客户端连接...");
                Socket socket = server.accept();
                System.out.println("一个客户端连接了!");

                /*
                 * 通过Socket获取输入流,可以读取到远端
                 * 计算机发送过来的字节。
                 */
                InputStream in = socket.getInputStream();
                InputStreamReader isr
                        = new InputStreamReader(in, StandardCharsets.UTF_8);
                BufferedReader br
                        = new BufferedReader(isr);

                Scanner scanner = new Scanner(System.in);
                OutputStream out = socket.getOutputStream();
                OutputStreamWriter osw = new OutputStreamWriter(out, StandardCharsets.UTF_8);
                BufferedWriter bw = new BufferedWriter(osw);
                PrintWriter pw = new PrintWriter(bw, true);

                String line = null;
                while ((line = br.readLine()) != null) {

                    System.out.println("客户端问:" + line);
                    String[] strs = line.split(" ");
                    int a = Integer.parseInt(strs[0]);
                    double X1 = Double.parseDouble(strs[1]);
                    double X2 = Double.parseDouble(strs[2]);
                    double X3 = Double.parseDouble(strs[3]);
                    double X4 = Double.parseDouble(strs[4]);
                    Complex complex1 = new Complex(X1, X2);
                    Complex complex2 = new Complex(X3, X4);
                    if (a == 1) {
                        String line1 = String.valueOf(complex1.ComplexAdd(complex2));
                        pw.println(line1);

                    }
                    if (a == 2) {
                        String line1 = String.valueOf(complex1.ComplexSub(complex2));
                        pw.println(line1);

                    }
                    if (a == 3) {
                        String line1 = String.valueOf(complex1.ComplexMulti(complex2));
                        pw.println(line1);

                    }
                    if (a == 4) {
                        String line1 = String.valueOf(complex1.ComplexDiv(complex2));
                        pw.println(line1);

                    }
                    if (a == 5) {
                        if (complex1.compareTo(complex2) == 1) {
                            System.out.println("The real part of the second imaginary number is larger");
                            String line1 = "The real part of the second imaginary number is larger";
                            pw.println(line1);
                        } else {
                            System.out.println("The real part of the first imaginary number is larger");
                            String line1 = "The real part of the first imaginary number is larger";
                            pw.println(line1);
                        }
                    }
                    if (a == 6) {
                        if (complex1.carry(complex2) == 1) {
                            System.out.println("The imaginary part of the second imaginary number is larger");
                            String line1 = "The imaginary part of the second imaginary number is larger";
                            pw.println(line1);
                        } else {
                            System.out.println("The imaginary part of the first imaginary number is larger");
                            String line1 = "The imaginary part of the first imaginary number is larger";
                            pw.println(line1);
                        }
                    }

                }

            }
        } catch (Exception e) {
            e.printStackTrace();
        }
}

客户端:

package complexRemoteCalculator;
/**
 * \* Created with IntelliJ IDEA.
 * \* User: Shape Of My Heart
 * \* Date: 2020/10/25
 * \* Time: 16:20
 * \* Besides,some of the best things in life are total mistakes.
 * \* Description:
 * \
 *
 * @author Shape Of My Heart
 */
import NBE2.Complex;
import RSA.RSAEncrypt;
import java.io.*;
import java.net.Socket;
import java.nio.charset.StandardCharsets;
import java.security.NoSuchAlgorithmException;
import java.util.Scanner;

public class calculatorClient {
    /*
     * java.net.Socket 套接字
     * 封装了TCP协议的通讯细节,使得我们可以通过它
     * 来与远端计算机建立TCP连接,并利用两个流的读写
     * 完成数据交互。
     */
    private Socket socket;

    /**
     * 构造方法,用来初始化客户端
     */
    public calculatorClient() {
        try {
            /*
             * Socket实例化是需要传入两个参数
             * 参数1:服务端IP地址
             * 参数2:服务端程序申请的端口
             * 我们通过IP可以找到网络上的服务端计算机
             * 通过端口可以连接到服务端计算机上运行的
             * 服务端应用程序了。
             * 注意:
             * 实例化Socket的过程就是连接的过程,若
             * 服务端没有响应这里会抛出异常。
             */
            System.out.println("正在连接服务端...");
            socket = new Socket("127.0.0.1", 8080);
            System.out.println("与服务端成功建立连接!");

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        calculatorClient client1 = new calculatorClient();
        client1.start();
    }


    /**
     * 客户端开始工作的方法
     */
    public void start() {
        try {
            Scanner scanner = new Scanner(System.in);
            /*
             * Socket提供的方法:
             * OutputStream getOutputStream()
             * 该方法获取的输出流是一个字节输出流
             * 通过这个流写出的字节会通过网络发送
             * 到远端计算机上(对于客户端这边而言,
             * 远端计算机指的就是服务端了。)
             */

            InputStream in = null;
            try {
                in = socket.getInputStream();
            } catch (IOException e) {
                e.printStackTrace();
            }
            InputStreamReader isr = null;
            isr = new InputStreamReader(in, StandardCharsets.UTF_8);
            BufferedReader br = new BufferedReader(isr);
            OutputStream out = socket.getOutputStream();
            OutputStreamWriter osw = new OutputStreamWriter(out, StandardCharsets.UTF_8);
            BufferedWriter bw = new BufferedWriter(osw);
            PrintWriter pw = new PrintWriter(bw, true);
            RSAEncrypt.genKeyPair();

            String line2 = null;
            while (true) {
                System.out.println("   Welcome!This is a complex remote calculator.\n");
                System.out.println("What kind of operations do you want?");
                System.out.println("1.Addition");
                System.out.println("2.Subtraction");
                System.out.println("3.Multiplication");
                System.out.println("4.Division");
                System.out.println("5.Compare the size of the real part");
                System.out.println("6.Compare the size of imaginary part");
                System.out.println("7.Quit");
                Scanner input = new Scanner(System.in);
                int a = input.nextInt();
                if (a < 1 || a > 7) {
                    System.out.println("error!please choose again");
                }
                System.out.println("Please enter the real part and imaginary part of the first imaginary number");
                int x = input.nextInt();
                int y = input.nextInt();
                Complex complex1 = new Complex(x, y);
                System.out.println("Please enter the real part and imaginary part of the second imaginary number");
                x = input.nextInt();
                y = input.nextInt();
                Complex complex2 = new Complex(x, y);
                String m1 = String.valueOf(complex1.getRealPart());
                String m2 = String.valueOf(complex1.getImagePart());
                String n1 = String.valueOf(complex2.getRealPart());
                String n2 = String.valueOf(complex2.getImagePart());
                String line = a + " " + m1 + " " + m2 + " " + n1 + " " + n2;
                pw.println(line);
                try {
                    if (!((line2 = br.readLine()) != null)) {
                        break;
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
                System.out.println("服务端计算结果为:" + line2);
            }
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

运行结果截图





三、实验过程中遇到的问题和解决过程

  • 问题1:当主机为客户端时无法连接到对方IP地址
  • 问题1解决方案:关闭WINDOWS防火墙

四、心得体会

  • 在这次实验过程中,我遇到了许多问题,其中既有知识上的漏洞,也有不细心导致的马虎,这一切都补充,完善,丰富,扩展了我的计算机知识体系。在不断修复问题的过程中,我使用了很多方式去查询资料,例如:《数据结构与面向对象程序设计》,博客园平台,CSDN平台,码云平台,知乎app,等。在Socket套接字的使用中,我还进一步熟悉了Intellij IDEA这个平台的使用与运行方式,提高了自己自主学习的能力,为我接下来学习数据结构以及JAVA语言程序设计打下了坚实的基础,并在不断探索的过程中逐步提升了自己。

五、参考资料

posted @ 2020-11-01 01:38  20192307常万里  阅读(140)  评论(0编辑  收藏  举报