46-Java编程案例六：数字加密（及解密）

案例六：数字加密及解密

• 需求：

  • 某系统的数字密码：比如1983，采用加密方式进行传输，规则如下：先得到每位数，然后每位数都加上5，再对10求余，最后将所有数字反转，得到一串新数。

• 分析：

  		1	9	8	3
  +5		6	14	13	8
  %10		6	4	3	8
  反转	8   3   4   6
  加密后的结果就是：8346
  

  • 创建键盘录入对象，用于录入系统密码
  • 录入系统密码并用变量接收
  • 定义一个加密方法，将系统密码进行加密后输出到控制台

• 实现：

  1. 创建键盘录入对象，用于录入系统密码
  2. 先输入密码的个数，再动态初始化一个数组password，用于存储系统密码，长度为输入的密码个数
  3. 录入一个四位数的系统密码，依次录入到数组password
  4. 定义一个打印数组的方法printArray，方便看加密前与加密后的区别：无返回值，设置一个形参：int[] arr——>用于接收传入的数组
  5. 在printArray内：
  	(5.1) 定义for循环遍历数组
  	(5.2) 输出数组元素
  6. 调用printArray方法，查看一下录入后的密码
  7. 定义一个密码加密的方法passwordSecret，无返回值，设置一个形参：int[] arr ——>用于接收传入的数组
  8. 在passwordSecret内：
  	(8.1) 定义for循环，对数组中的每一位密码进行加密：例如——>arr = [1, 9, 8, 3]，
  		  例如：i = 先1，后9，再8，终3; 依次对这几位密码进行+5，后对10求余的运算;
  		  先+5，后对10求余，然后重新赋值到原位置.
  	(8.2) 加密后，再对密码进行反转——>数组元素交换:
  		  此时，arr = [6, 4, 3, 8]，反转后：arr = [8, 3, 4, 6]，得到最终加密结果;
  		              i        j
  		  定义for循环，初始化语句：i=0, j = 数组长度-1(表示最后一位)，循环条件：i < j，迭代语句：i自增(表示往前走), j自			减(表示往回走).
  	(8.3) 直接交换两者位置的值即可:
  		  定义临时变量，将j位置的值先存起来;
  		  将i位置的值 赋值给 j位置的值;
  		  再将临时变量里的j位置的值 赋值 给i位置的值.
  	(8.4) 完成反转后，调用printArray方法将加密后的数组元素打印输出
  9. 调用passwordSecret方法，完成加密后，输出
  

package com.app.demo;

import java.util.Scanner;

/**
    案例六：数字加密
        - 需求：
            - 某系统的数字密码：比如1983，采用加密方式进行传输
            规则如下：先得到每位数，然后每位数都加上5，再对10求余，最后将所有数字反转，得到一串新数。
        - 分析：
                    1	9	8	3
             +5		6	14	13	8
             %10	6	4	3	8
             反转	8   3   4   6
             加密后的结果就是：8346

             - 创建键盘录入对象，用于录入系统密码
             - 录入系统密码并用变量接收
             - 定义一个加密方法，将系统密码进行加密后输出到控制台
 */
public class Test6 {
    public static void main(String[] args) {
        // 1. 创建键盘录入对象，用于录入系统密码
        Scanner sc = new Scanner(System.in);

        // 2. 先输入密码的个数，再动态初始化一个数组password，用于存储系统密码，长度为输入的密码个数
        System.out.println("请您输入需要加密的密码个数: ");
        int length = sc.nextInt();
        int[] password = new int[length];

        // 3. 录入一个四位数的系统密码，
        for (int i = 0; i < password.length; i++) {
            // i = 0 1 2 3
            System.out.println("请输入第" + (i+1) + "位系统密码: ");
            int writePassword = sc.nextInt();

            // 依次录入到数组password
            password[i] = writePassword;
        }

        // 6. 调用printArray方法，查看一下录入后的密码
        System.out.print("\n加密前的密码: ");
        printArray(password);

        // 9. 调用passwordSecret方法，完成加密后，输出
        System.out.print("\n加密后的密码: ");
        passwordSecret(password);
    }

    // 4. 定义一个打印数组的方法printArray，方便看加密前与加密后的区别：无返回值，设置一个形参：int[] arr——>用于接收传入的数组
    public static void printArray(int[] arr) {
        // 5. 在printArray内：
        // (5.1) 定义for循环遍历数组
        for (int i = 0; i < arr.length; i++) {
            // (5.2) 输出数组元素
            System.out.print(arr[i]);
        }
    }

    // 7. 定义一个密码加密的方法passwordSecret，无返回值，设置一个形参：int[] arr ——>用于接收传入的数组
    public static void passwordSecret(int[] arr) {
        // 8. 在passwordSecret内：
        // (8.1) 定义for循环，对数组中的每一位密码进行加密：例如——>arr = [1, 9, 8, 3]，
        for (int i = 0; i < arr.length; i++) {
            // 例如：i = 先1，后9，再8，终3; 依次对这几位密码进行+5，后对10求余的运算
            // 先+5，后对10求余，然后重新赋值到原位置
            arr[i] = (arr[i] + 5) % 10;
        }

        // (8.2) 加密后，再对密码进行反转——>数组元素交换
        // 此时，arr = [6, 4, 3, 8]，反转后：arr = [8, 3, 4, 6]，得到最终加密结果
        //             i        j
        // 定义for循环，初始化语句：i=0, j = 数组长度-1(表示最后一位)，循环条件：i < j，迭代语句：i自增(表示往前走), j自减(表示往后走)
        for (int i = 0, j = arr.length-1; i < j; i++, j--) {
            // (8.3) 直接交换两者位置的值即可
            // 定义临时变量，将j位置的值先存起来
            int temp = arr[j];

            // 将i位置的值 赋值给 j位置的值
            arr[j] = arr[i];

            // 再将临时变量里的j位置的值 赋值 给i位置的值
            arr[i] = temp;
        }

        // (8.4) 完成反转后，调用printArray方法将加密后的数组元素打印输出
        printArray(arr);
    }
}

输出结果：

测试1：
-----------------------------
请您输入需要加密的密码个数: 
4
请输入第1位系统密码: 
1
请输入第2位系统密码: 
9
请输入第3位系统密码: 
8
请输入第4位系统密码: 
3

加密前的密码: 1983
加密后的密码: 8346
-----------------------------

测试2：
-----------------------------
请您输入需要加密的密码个数: 
6
请输入第1位系统密码: 
4
请输入第2位系统密码: 
6
请输入第3位系统密码: 
5
请输入第4位系统密码: 
3
请输入第5位系统密码: 
2
请输入第6位系统密码: 
8

加密前的密码: 465328
加密后的密码: 378019
-----------------------------

总结

1、如何完成数组元素的反转的？

• 1. for循环定义2个变量分别占数组的首尾位置，首部位置的值 一定要小于 尾部位置的值 才进行交换，首部自增就是往前走，尾部自减就是往回走

  for(int i = 0, j = arr.length-1; i < j; i++, i--) {}
  //		首		    尾
  

• 2. 定义1个临时变量，将尾部位置的元素存起来

  for(int i = 0, j = arr.length-1; i < j; i++, i--) {
  //		首		    尾
      int temp = arr[j];	// 尾部位置的值
  }
  

• 3. 将首部位置的值赋值给尾部位置的值

  for(int i = 0, j = arr.length-1; i < j; i++, i--) {
  //		首		    尾
      int temp = arr[j];	// 尾部位置的值
      arr[j] = arr[i];	// 首 赋值给 尾
  }
  

• 4. 最后将存在临时变量里的尾部位置的值赋值给首部位置的值，完成反转

  for(int i = 0, j = arr.length-1; i < j; i++, i--) {
  //		首		    尾
      int temp = arr[j];	// 尾部位置的值
      arr[j] = arr[i];	// 首 赋值给 尾
      arr[i] = temp;		// 尾 赋值给 首
  }
  

练习：将加密后的密码进行解密

• 需求
  • 某系统的数字密码加密后：比如1983加密后为8346，将8346解密为1983
• 数学的魅力：其实我们上面写的加密程序，其实也是解密程序

输出结果：

请您输入需要加密的密码个数: 
4
请输入第1位系统密码: 
8
请输入第2位系统密码: 
3
请输入第3位系统密码: 
4
请输入第4位系统密码: 
6

解密前的密码: 8346
解密后的密码: 1983

• 想知道是为什么？
• 可以使用Debug工具，打断点，一步一步执行，看清楚就知道了，在这里打断点会比较好！！