9.25

工作内容

使用 OpenSSL 给 Tomcat 配证书

接着昨天的

1、访问https://192.168.110.133:8443，仍然提示不安全

2、

 

3、根据证书状态的描述，将证书的位置移到“受信任的根证书颁发机构”存储区中。

4、重新启动tomcat后，问题仍未得到解决

5、在证书的高级选项中，把证书目的的勾全部打上。

6、仍然失败，讲tomcat的server.xml文件恢复备份，重新编辑一次。

7、仍然失败。请教老师，是因为服务器与浏览器并不是一个地址，证书在访问IP地址时不生效，只对域名生效。于是重新在windows上配置tomcat。

 

在windows上用openssl给tomcat配置证书

1、安装tomcat

下载、解压过程略。

2、配置环境变量

3、用命令行安装

4、重复证书生成、导入的步骤。

edge浏览器仍然失败，换成IE浏览器，成功。

 

通过「绕道」的办法：利用计算机对域名的识别「漏洞」,用 OpenSSL 给 Tomcat 配证书

1、在阿里云上申请免费证书

2、申请完成后下载、解压

3、更改别名

keytool -changealias -keystore 6342246_xuxumiao.xyz.pfx -alias alias -destalias tomcat

4、修改host文件。

增加一个映射。

 5、命令行验证一下。

映射成功。

6、停止tomcat服务，修改server.xml文件如下：

7、打开浏览器，进入localhost:8080，成功

8、访问https://localhost:8443。也成功..奇怪了，可能是因为之前配置本地服务器的时候已经把证书设置好了。

9.26

工作内容

任务4.1

某地区的外卖小哥配送费标准如下（以下标准纯属杜撰，如有雷同，纯属巧合）：

如果外卖小哥李雷送了一次距离为 3.7 公里的外卖，请用代码计算出他所应收取的费用

• 正常收费时段（含汤水/不含汤水）

含汤水：

不含汤水：

• 夜间收费时段（含汤水/不含汤水）

含汤水：

不含汤水：

• 如果外卖小哥李雷分别在早上（2.7 公里，含汤水）、中午（7 公里，含汤水）、下午（12 公里，不含汤水）及夜间（23:00～5:00，3.6 公里，含汤水）送餐，用代码计算出他所应收取的总费用。

• 如果外卖小哥李雷能够按以上规律连续地接单一周（假设时间段、里程和附加费都一样），那么用代码计算出他所应收取的总费用。

• 如果外卖小哥张伟按早上（2.9 公里，不含汤水）、中午（7.6 公里，含汤水）、下午（9.1 公里，含汤水）、晚上（5 公里，不含汤水）及夜间（23:00～6:00，4.3 公里，不含汤水）规律地连续送餐一周（假设时间段、里程和附加费都一样），那么用代码计算出他俩所应收取的总费用。

package com.xxm.task4;
/*
最低配送费（1公里内起步价，超出后除起步价外，减去1公里后再按每公里单价累加费用）         5 元
5 公里内每公里单价                                                               2 元/公里
超过 5 公里需增加额外配送费                                                           8 元
超过 10 公里需增加额外配送费                                                         20 元
汤水附加费                                                                        3 元/次
夜间收费  23：00 至次日 6：00 送餐时，在总费用（含附加费）上加收               50%的额外费用
注：所有里程数向上取整，例如送餐距离为 2.1 公里，那么按 3 公里算
*/
/*
    思路：
    首先，录入数据有2-3个：配送里程（必要）、配送时间（必要），配送天数（非必要，考虑放在循环外）
    主循环用if语句：判断里程，输出里程价格    &   判断是否有汤水 &   判断是否夜间配送
    循环结束，询问是否继续查询。输入y，则重新循环，计算总价。输入n，则中断循环，询问送餐天数。
    计算总共价格，并打印。
    定义变量：
    录入里程：milesInput     计算里程：miles
    配送时间：timeInput      计算时间（是否夜间）：time
    是否有汤水：soup
    送餐次数：days
    每一单的价价:sumThisOrder
    总价：sum
    是否另一单：otherOrder
*/
import java.util.Scanner;

public class quest1_takeout {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        int sum = 0;   //定义总价
        lo1:
        while (true) {  //死循环，以达到录入多单、多快递员的情况
            //计算里程价格
            int sumThisOrder = 0;
            System.out.println("请输入配送里程：");
            while (true) {    //用死循环来完成数据录入
                double milesInput = sc.nextDouble();
                int miles = (int) Math.ceil(milesInput); 
        //录入里程，并向上取整转化为计算里程
                if (milesInput <= 0) {          //判断录入数据是否合理
                    System.out.println("输入错误！请输入正确的配送里程：");
                } else if (miles < 5) {
                    sumThisOrder = sumThisOrder + 5 + (miles - 1) * 2;  
        //5公里内，价格等于（起步价+里程数-1）×里程单价
                    break;
                } else if (miles < 10) {
                    sumThisOrder = sumThisOrder + 5 + 4 * 2 + 8;
                    break;
                } else if (miles < 20) {
                    sumThisOrder = sumThisOrder + 5 + 4 * 2 + 8 + 20;
                    break;
                }
            }

            //计算汤水附加费
            while (true) { //死循环：数据录入
                System.out.println("请输入是否有汤水（1代表有汤水，0代表没有汤水)：");
                int soup = sc.nextInt();
                if (soup != 0 && soup != 1) {
                    System.out.println("输入错误，请输入1或者0：");
                }
                if (soup == 1) {
                    sumThisOrder += 3;
                    break;
                }
                if (soup == 0) {
                    break;
                }
            }
            //计算夜间配送费
            while (true) {
                System.out.println("请输入配送时间点（24小时制的时刻，输入小时即可）");
                int timeInput = sc.nextInt();
                if (timeInput < 0 || timeInput > 24) {
                    System.out.println("输入错误！请输入正确的时间");
                } else if (timeInput >= 23 || timeInput <= 6) {
                    sumThisOrder *= 1.5;
                    break;
                } else {
                    break;
                }
            }
            System.out.println("这一单的应收取的费用为：" + sumThisOrder);
            sum += sumThisOrder;
            //至此，一单的价格已经计算完毕，开始计算第二单或者第二名快递员。
            while (true) {
                System.out.println("还要录入其它订单吗？（输入y表示是，n表示否）");
                String anotherOrder = sc.next();
                switch (anotherOrder) {
                    case "n":
                        break;
                    case "y":
                        continue lo1;
                    default:
                        System.out.println("输入错误！请重新输入！");
                        continue;
                }

                //单日总价计算完毕，计算配送一定天数的总价
                while (true) {
                    System.out.println("请输入配送天数：");
                    int days = sc.nextInt();
                    if (days <= 0) {
                        System.out.println("输入错误！请输入正确的天数");
                    } else {
                        sum = sum * days;    
        //在这行代码之前，sum都是每日的总价，至此，sum表示N天的总价，可以输出总报酬了。
                        System.out.println("这" + days + "天的应收取的总费用为：" + sum + "元");
                        break lo1;
                    }
                }
            }
        }
    }
}

 

任务4.2.1

求斐波那契数列前50项之和。

代码如下：

package com.xxm.task4;

//计算斐波那契数列之和（N = 50）
public class quest2_1_Fibonacci {
    public static void main(String[] args) {
        fibonacci_sum(50);
    }

    static void fibonacci_sum(int N) {
        long[] fibo = new long[N];
        fibo[0] = 1;
        fibo[1] = 1;
        long sum = 2;
        for (int i = 2; i < fibo.length; i++) {
            fibo[i] = fibo[i - 2] + fibo[i - 1];
            sum += fibo[i];
        }
        System.out.println(sum);
    }
}

输出结果：

 

不过好像并没有用到递归的思想，再来一段递归版本：

package com.xxm.task4;

public class quest2_1_Fibonacci2 {
    //计算斐波那契数列之和（N = 50）,用递归法
    public static void main(String[] args) {
        //   System.out.println(fibonacci( 50));
        fibonacci_sum(50);
    }

    private static long fibonacci(int N) {  //定义方法，录入递归次数
        if (N == 0 || N == 1) {
            return N;
        } else {
            return (fibonacci(N - 2) + fibonacci(N - 1));
        }
    }

    static void fibonacci_sum(int N) {
        long sum = 0;
        for (int i = 0; i <= N; i++) {
            sum = sum + fibonacci(i);
        }
        System.out.println("斐波那契数列前" + N + "项的和为" + sum);
    }
}

结果如下：

 任务4.2.2

计算 10 的阶乘

package com.xxm.task4;

public class quest2_2_Factorial {
    public static void main(String[] args) {
        facotrial(10);
    }

    static void facotrial(int n) {
        long result = 1;
        for (int i = 0; i < n; i++) {
            result = result * (i + 1);
        }
        System.out.println(n + " 的阶乘是 " + result);
    }
}

输出结果：

递归版本：

package com.xxm.task4;

public class quest2_2_Factorial2 {
    public static void main(String[] args) {
        int N = 10;
        System.out.println("N的阶乘是" + fac(N));
    }

    static long fac(int n) {
        if (n == 1) {
            return 1;
        } else {
            return fac(n - 1) * n;
        }
    }
}

输出结果：

任务4.2.3

对数组[8, 2, 11, 9, 1, 5, 3]使用二分算法进行排序。

代码如下：

package com.xxm.task4;
//对数组[8, 2, 11, 9, 1, 5, 3]使用二分算法进行排序
//二分法插入排序，简称二分排序，
// 是在插入第i个元素时，对前面的0～i-1元素进行折半，
// 先跟他们中间的那个元素比，如果小，则对前半再进行折半，
// 否则对后半进行折半，直到left<right，
// 然后再把第i个元素前1位与目标位置之间的所有元素后移，再把第i个元素放在目标位置上。

public class quest2_3_BinaryInsertSort {
    public static void main(String[] args) {
        int arr[] = new int[]{8, 2, 11, 9, 1, 5, 3};
        binaryInsertSort(arr);
    }

    static void binaryInsertSort(int[] arr) {
        for (int i = 1; i < arr.length; i++) {
            int left = 0;
            int right = i - 1;//定义左右指针。
            int temp = arr[i];
            int mid;    //定义中间指针
            while (left <= right) { //循环：当左指针<右指针时
                mid = (left + right) / 2;    //给中间指针赋值，当数组有偶数个数据时，中间指针指向中间偏左那一个数据
                if (temp < arr[mid]) {
                    right = mid - 1;//如果当前数组数据<中间指针所指数据，则把中间指针左移，并取前半段继续下一步二分
                } else {
                    left = mid + 1;  //如果当前数组数据>=中间指针所指数据，则把中间指针右移，并取后半段继续下一步二分
                }   //这个while循环结束后，left<right
            }
            // 然后再把第i个元素前1位（j）与目标位置（left）之间的所有元素后移，再把第i个元素（arr[i]=temp）放在目标位置上。
            for (int j = i - 1; j >= left; j--) {
                arr[j + 1] = arr[j];
            }   //i元素前一位（j）与目标位置（left）之间所有元素元素右移
            arr[left] = temp;   //第i个元素（arr[i]=temp）放在目标位置（left）
        }
        System.out.print("排序后的数组为 ");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + ",");
        }
    }
}

结果如图：

 

C1任务22

现需要设置`a`的顶部外边距，请补齐代码片段

答：a代表行内元素，行内元素的上下边距不可控制，所以需要将其转为块级元素。所以横线处应该填block。

C1任务23-1

 答：标准盒模型中，width和heitght是内容区的宽和高，还要加上padding区、border区宽高才能得到整个模型的实际宽高。

border未设置，视为0。

因此整个模型的高度为5+100+5=110px

C1任务23-2

现有如下代码片段，请问标准盒模型中 div 的实际占位高度是________px。

答：思路跟上一题差不多，10+10+100=120px。

任务23-3

如下代码片段，请问标准盒模型中`div`的实际占位高度为______px，

答：思路还是跟上一题差不多，注意margin的简写方式。

5+100+5=110px。

 

任务4.2.4

和数分解：把一个数分解成任意几个数的和，并把所有的可能性都列出来

任务4.2.5

用回调实现下面这两种常见的生活场景：

张伟在超市买了一瓶快乐水和一些吃的，使用支付 APP 完成支付后，过了几秒，APP 通知他已经支付成功

李雷周一在某某宝 APP 上买了两张周五晚上的电影票。在周五晚上电影即将放映的前一小时，APP 给他发来了观影通知

韩梅梅周末在家休息，她把衣服丢到洗衣机里之后就去扫地、做饭去了，过了一会，洗衣机就「嘀～嘀～」响几声通知她衣服已经洗好了

 

 

 

学习内容

不好起标题的知识点

在java中，如果看到类型+名称（例如int a），说明这是在声明变量或者方法。

如果名称后面跟着圆括号，那么这是在声明一个新方法。 int xxm();

如果后面没有括号，那么这是在声明一个变量。int xxm;

向上、向下取整

Math.ceil(double a)    //向上取整，ceil，天花板

Math.floor(double a)    //向下取整，floor，地板

有关录入函数

之前自学的时候只用过

int a = sc.nextInt();

这个方法只能接受整型数据。

今天做题的时候因为要接收doubles型数据，类推了一下，可以把Int改成Double。

如:

double b = sc.nextDouble();

当然，左边声明变量的类型也要变。long、boolean等同理。

注意注意：如果要录入字符串，则直接用next()就行。

string c = sc.next();

continue lo

自己只学过 break lo（中断特定循环）。

今天在写的时候需要继续某个循环，于是尝试了一下continue lo，发现可以指定某个循环继续。

 

字符串比较

字符串的比较应该用equals()，而不是==。

例如

String s = "xxm";
sout(s.equals("xxm");
>>>true


sout(s.equals("java");
>>>false

递归法

程序调用自身的编程技巧称为递归（ recursion）。 一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。

递归有三要素：边界条件、递归前进段和递归返回段。

当边界条件不满足时，递归前进；当边界条件满足时，递归返回。

二分排序

二分法插入排序，简称二分排序，是在插入第i个元素时，对前面的0～i-1个元素进行折半，先跟他们中间的那个元素比，如果小，则对前半再进行折半，否则对后半进行折半，直到left<right，然后再把第i个元素前1位与目标位置之间的所有元素后移，再把第i个元素放在目标位置上。

但这段话是我从百度百科复制的，读起来很绕。

为了更好的使用二分排序法。我决定自己组织一下语言描述一下二分排序法。

假设有数列{2,19,36,5,10,8,1}

二分排序法的第一步：

从第二个（i=1）开始，选中一个数，

将这个数和他前面的i个数比较（这里有一个隐藏的信息：这个数的前i个数是已经排序好了的），

比较过程如下：先比这前i个数的中间这个数，如果比中间数大就比后半部的中间，以此类推、

如果比中间数小就比前半部的中间，以此类推，直到没有数字可以比较，此时（标志：左指针比右指针大）就是这个数要放的位置。

将数放在这个位置的方法，就是把这个位置到这个数在原来数列的位置的数全部右移，然后自己差在最前面。

至此，第一个数的排序完成，进入第二个数，以此类推，到最后一个数，排序完成。

 

 

 

遇到的问题及解决办法

问题1：

package com.xxm.task4;

public class quest2_1_Fibonacci2 {
    //计算斐波那契数列之和（N = 50）,用递归法
    public static void main(String[] args) {
        fibonacci_sum(50);
    }

    static void fibonacci_sum(int N) {  //定义方法，录入数组长度
        long[] arr = new long[N + 1]; //定义数组
        long sum = 0;
        arr[0] = 0;
        arr[1] = 1;//定义第一项（其实数组的第1项是0，但是该项的索引也是0，正好弃用）
        arr[N] = arr[N - 2] + arr[N - 1];   //第N项的数据为前两项之和
        for (int i = 0; i < N; i++) {
            sum += arr[i];
        }
        System.out.println("斐波那契数列前" + N + "项的和为" + sum);
    }
}

在使用以上代码完成递归时，数列的和为全0。

这是因为long型数组静态初始化时，未赋值的项都是0

解决方法：

放弃使用数组，直接用方法。

 

明日计划

1、先了解算法可视化任务。

2、了解了算法可视化之后，再利用算法可视化，回来搞递归和回调，这样对递归、回调的了解也更直观。

3、递归和回调搞完！