Java学习第一周（2.20~2.24）

最新推荐文章于 2024-09-15 19:46:31 发布

super_码

最新推荐文章于 2024-09-15 19:46:31 发布

阅读量297

点赞数

文章标签： java 学习方法程序人生 Powered by 金山文档

本文链接：https://blog.csdn.net/qq_45926882/article/details/129212053

版权

前情：要想看懂源码，Java基础不能丢，在学习Java基础时不能掉以轻心，不然经年累月小问题也会变成大问题。

一、day01：学习的内容包括环境安装、JDK&JRE、如何在命令提示符窗口执行Java文件、安装idea、idea的简单使用、idea项目中的目录结构、注释、分隔符、标识符、关键字、数据类型(简单认识)、主函数&输出语句

1、其中环境配置的主要内容包括：

(1)我的电脑-->属性-->高级系统设置

(2)高级：环境变量

(3)在上方或者下方新建一个名为JAVA_HOME的变量，变量值填自己jdk所在的目录

(4)找到名为path的变量双击，新建一个目录可以是jdk所在目录加上bin目录，或者前一步完成了直接使用%JAVA_HOME%\bin，后者比前者能更快查找，也能把将该目录上移以便于在寻找执行的速度能快一点

(5)检查是否配置成功：win+r-->cmd打开命令提示符窗口，先后输入java和javac检查是否配置和安装成功

2、jdk&jre：

jre是java的运行时环境,包含了java的虚拟机,java基础类库。是使用java语言编写的程序运行所需要的软件环境，是提供给想要运行java程序的用户使用的

jdk:是java程序的开发工具包，是程序员使用java语言编写java程序所需要的开发工具包,提供给程序员使用的；包含jre

3、明白了java程序的运行原理和过程，java程序在执行时先将源码进行编译生成一个.class文件再进行反编译最后输出结果

4、idea的项目目录结构

项目:project

module:模块

src:这个文件夹是存放java文件的根目录

包(package):作用是将具有相同的格式或者性质的文件分包进行处理

右键单击src ---> new ---> package

包的名称使用域名倒置的写法，比如你有一天去淘宝(www.taobao.com)工作了，项目的包就应该是:com.taobao.分支名称。

类(class):存放在包中,并且是参与程序执行的最小单元

右键单击包名 ---> new ---> class

类的名称使用

1、首字母大写

2、只能使用字母,数字,下划线(_),美元符号($)

3、数字不能作为开头

4、不能使用关键字

5、使用驼峰式命名法, 每个单词的首字母大写

6、做到见名知意,一个包中不能有相同名字的类

5、注释、分隔符、标识符、关键字的注意内容：标识符是给变量,类,方法,包,取名字的；

二、day02：数据结构&运算符

1、java体系：

JavaSE 标准版 java基础,桌面应用开发

JavaEE 企业版 javaweb、网站

JavaME 微型版被安卓给取代了

2、变量：

(1)命名规则：

必须复合标识符的命名规范,阿里编程规约中变量名使用小驼峰式命名法。第一个单词首字母小写,从第二个开始每个单词的首字母大写

(2)基本数据类型：

基本数据类型

整型(整数): byte(字节型) short(短整型) int(整型最常用的数据类型) long(长整型)

浮点型(小数): float(单精度浮点型) double(双精度浮点型)

字符型(一个字符): char

布尔类型(判断对错): boolean

引用数据类型:除基本类型之外都是引用数据类型

String:比一些基本数据类型还常用的引用数据类型,表示对字符串信息进行处理

(3)变量的区别：

	成员变量	局部变量
定义的位置不同	定义在类里面,也就是class后面类名的大括号里面	定义在方法或者代码块中,如果说是方法的参数,也是局部变量
作用域不同	在整个类中都可以使用	在方法或者代码块中使用
初始值不同	如果没有给变量进行赋值,则java的系统会给变量一个初始值	必须手动进行赋值,才可以进行使用
内存存储位置不同	堆里面,和对象的生命周期是一致的	存储在栈里面，和方法的生命周期一致

(4)整数类型：

	字节数	取值范围
byte 字节型	1(8位)	-2 ^ 7 ~ 2 ^ 7 - 1 [-128 ~ 127]
short 短整型	2(16位)	-2 ^ 15 ~ 2 ^ 15 - 1[-32768 ~ 32767]
int 整型	4(32位)	-2 ^ 31 ~ 2 ^ 31 - 1
long 长整型	8(64位)	-2 ^ 63 ~ 2 ^ 63 - 1

(5)自动类型提升和强制类型转换，

默认整数类型是int型，赋值强转就在数值后面加上想要转换类型的首字母，这里long类型建议大写，以便于和1进行区分；当我们给long类型进行赋值的时候,如果超过了int类型的最大值范围,那么我们就在赋值的数后面加上一个L

(6)整数的不同进制表示：

 //二进制使用0b进行开头 0 1
        int a = 0b10;
        System.out.println("a = " + a);

        //八进制使用0进行开头 0 1 2 3 4 5 6 7
        int b = 010;
        System.out.println("b = " + b);

        //十进制
        int c = 20;
        System.out.println("c = " + c);

        //十六进制0x开头 0 1 2 3 4 5 6 7 8 9 A B C D E F
        int d = 0x10;
        System.out.println("d =" + d);

(7)浮点类型：

	float	double
名称	单精度浮点类型	双精度浮点类型
字节	4	8
精度问题	保留小数点后面8位	保留小数后面16位

注意：1.默认使用double类型，当对浮点类型的变量进行赋值整数时能自动转换成小数

2.给float赋值小数时应该在后面加上一个f或者F

3.小数在进行运算的时候可能会出现精度丢失的问题,在java中已经出具一个特殊的类,专门进行小数精度的确认

//在计算机的运算过程中,首先将小数转换成2进制,然后使用2进制进行计算,计算完成之后
        //再将元素转换为10进制,在转换的过程中就出现了小数运算精度丢失的问题
        double k1 = 0.01;
        double k2 = 0.05;
        System.out.println(k1 + k2);//0.060000000000000005

        //想要进行精度元素,需要先对java本身已经提供的精确运算的类进行创建对象
        //创建对象的语法:类名 对象名 = new 类名();
        BigDecimal d1 = new BigDecimal("0.01");//以字符串的形式将元素放进来
        BigDecimal d2 = new BigDecimal("0.05");
        //怎么计算?
        //加:对象名.add(第二个对象名);
        //除:对象名.divide(第二个对象名);
        //乘:对象名.multiply(第二个对象名);
        //减:对象名.subtract(第二个对象名);

(8)布尔类型：

只有true和false两个值，但是这个类型经常使用,使用在分支,三目运算符,逻辑运算,比较,for循环中...都有使用，因为我们需要使用判断的场景的时候就需要使用boolean类型进行表示

(9)字符型：

1.ASCII码表

2.

ASCII码:美国信息交换标准码,是一套编码方案,能够帮我们进行元素之间信息的转换

一共0 ~ 127共128个字符

32:空格

48 ~ 57 : 0 ~ 9

65 ~ 90 : A ~ Z

97 ~ 122 : a ~ z

可以直接对char类型进行整数类型赋值

或者将一个整数值,赋值给一个char类型

三、day03：位运算&Scanner&Random&流程控制

1、位运算符

(1)位运算符：

&:按位与:如果两个都为1,那么结果就是1,中间有一个数是0,结果就是0
    |:按位或:如果有一个是1,结果就是1
    ^:按位异或:(同假异真)
    ~:按位取反: 将0变成1,将1变成0
    >>有符号右移
    <<左移
    >>>无符号右移
比如有一个数是5,另外一个数是7
首先将其转换为2进制
5：0101
7：0111
&：0101
|：0111
^：0010
>>: m >> n,将m转换成二进制,然后向右移动n位
    如果m为正数,就在前面补n个0
    如果m是负数,就在前面补n个1
<<: m << n,将m转换为二进制,然后向左移动n位
    不分正负号,然后再后面补n个0
>>>: m >>> n,将m转换成二进制,然后向右移动n位,
    不分正负号,然后再前面补n个0

(2)原码，补码，反码，负数的二进制编码

原码:正数的二进制原码就是使用方法进行取出的原来的数,负数的原码是想对其进行取绝对值,然后对其绝对值进行二      进制转换
反码:将原来原码的数值进行取反
补码:是在反码的基础上加1的处理
负数转2进制
以-9为例,演示如何将其转换成二进制数,使用辗转相除的方法进行而二进制处理的时候取出的是余数
1、9:0000 1001 叫原码
2、对上面的数进行原码取反,得到反码
     1111 0110
   补码是在反码的基础上加1
        1111 0111
3、将二级制负数转换成10进制
   将1111 0111进行减1处理
   然后对这个数进行取反
   再对其进行相反数操作

(3)运算符优先级：

2、Scanner扫描器：作用是和用户进行信息交互

(1)使用Scanner扫描器的步骤：

        //1、创建对象
        //   类名 对象名 = new 类名();
        //Scanner的扫描器除了对象名自己定义其余都是已经固定好的
        //系统输入:System.in   System.out:系统输出   println:打印
        //2、导包:就是找到这个类在java类库中的地址
        //   光标放在报错的位置,clt(Alt) + 回车找到import class ,找到系统工具包
        Scanner sc = new Scanner(System.in);
        //3、要告诉用户应该输入什么东西
        System.out.println("请输入你的年龄:");
        //4、需要使用一个变量来接收用户输入的信息
        //   当我们输入完成信息之后,需要按下回车键,告诉电脑我已经输入完毕了
        //   sc就是上面的扫描器,nextInt():扫描器中的方法要到控制台中去找一个
        //   整数类型的元素获取到,给到变量
        int age = sc.nextInt();

(2)Scanner输入的值：除了char类型之外八种基本数据类型都可以使用Scanner进行接收，如果以后想要进行char类型元素的获取,就使用String类型

//用String类型获取用户输入的字符串使用toCharArray()方法进行转换，转换成char类型的数组
Scanner sc = new Scanner(System.in);
        String sex = sc.next();
        char[] s = sex.toCharArray();//将字符串转换成字符数组
        System.out.println(Arrays.toString(s));//将数组以字符串形式进行输出
        char ss = s[0];//取出数组中某一个位置上的值
        System.out.println("ss = " + ss);

3、Random随机数：

(1)使用Random随机数步骤：

public class Random_01 {
    public static void main(String[] args) {
        //创建对象
        //类名 对象名 = new 类名();
        Random r = new Random();
        //默认生成一个0 - 1之间的小数,包含0但是不包含1
        double a = r.nextDouble();
        System.out.println("a = " + a);

        //生成int范围内的数
        int b = r.nextInt();
        System.out.println("b = " + b);

        //生成0 ~ n之间的整数,包含0但是不包含n
        int c = r.nextInt(100);
        System.out.println("c = " + c);

         //手动输入一个整数n，然后生成0~n之间范围内的随机数
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个正整数：");
        int n = sc.nextInt();
        int f = r.nextInt(n);
        System.out.println("0~"+n+"范围内的一个随机数为："+f);


        //生成65~90之间的整数然后将其转换成char类型字符输出
        int m = r.nextInt(26)+65;
        char ch1= (char) (m/10+'0');
        char ch2= (char)(m%10+'0');
        System.out.println("65~90之间的一个随机数为："+m);
        System.out.println("转换成char类型字符为:"+ch1+ch2);
    }
}

4、流程控制：

//语法1
/**
 * 分支语句是一个代码块,在我们项目过程中是很常用的一个技术
 * 根据我们的需求进行程序的执行
 * 语法:
 *  if(条件表达式){
 *      执行语句;
 *  }
 *  执行过程:
 *      如果条件表达式符合,就执行语句内容,
 *      如果条件不符合,就不执行
 *  注意:
 *      当只有一个判断条件并且只有一条语句的时候,我们可以省略大括号不写
 */

//语法2
/**
 * 语法:
 *  条件表达式是一个boolean类型的值
 *  if(条件表达式){
 *      语句1;
 *  }else{
 *      语句2;
 *  }
 * 执行过程:
 *  当条件表达式为正确的时候,就执行语句1
 *  当条件表达式为错误的时候,就执行语句2
 *
 * 随机一个0 ~ 100之间的整数,判断这个数是不是3的倍数,或者这个数是否包含3
 * 3的倍数: n % 3 == 0
 * 个位是3: 13 23 33 43... 整数和整数之间进行运算,得到的一定是整数 n % 10 == 3
 * 十位是3: 31 32 33 34 35 36... n / 10 == 3
 */

//语法3
/**
 * if...else if...
 * 语法:
 *  if(条件表达式1){
 *      语句1;
 *  }else if(条件表达式2){
 *      语句2;
 *  }else if(条件表达式3){
 *      语句3;
 *  }
 *  ....
 *  else{
 *      语句n;
 *  }
 *
 *  执行过程:
 *      哪个条件表达式的结果为正确,就执行哪个语句,
 *      如果所有的表达式都是错误的,那么就执行最后一个
 *      else后面的语句
 */

//语法4
/**
 * switch里面的条件表达式是一个值
 * 语法:
 * 给一个条件值;
 * switch(条件表达式){
 *     case 值1:
 *          语句1;
 *          break;//将程序停止的关键字
 *     case 值2:
 *          语句2;
 *          break;
 *     case 值3:
 *          语句3;
 *          break;
 *          ...
 *     default:
 *          语句n;
 *          break;
 * }
 * 执行过程:
 *  如果条件表达式的值和case后面的值相同,就选择相应的语句进行执行
 *  执行完成执行break将条件语句停止掉
 * 如果忘记写break会出现case穿透
 *
 * case后面可以是哪些值?
 * 基本数据类型:byte short char int
 * 基本数据类型的封装类型:Byte Short Character Integer
 * 枚举类型:enum
 * 字符串类型:String(jdk1.7 之后开始支持)
 */

5、练习：

/**
 * 2、随机一个200以内的偶数 和一个200以内的奇数，打印这两个数，再打印它们的和 及 差。
 */
public class test_02 {
    public static void main(String[] args) {
        Random rd = new Random();
        int a = rd.nextInt(100) * 2;
        System.out.println("偶数是"+a);
        int b = rd.nextInt(100) * 2 + 1;
        System.out.println("奇数是"+b);
        System.out.println("两数之和为：" + (a+b));
        if (a>b){
            System.out.println("两数之差为：" + (a - b));
        }else{
            System.out.println("两数之差为：" + (b - a));
        }
}
//这个题把范围之间的奇数和偶数进行乘2和乘2加1操作十分便捷，但是我使用的for循环死循环不断产生
//随机数进行判断是否能被2取余为0，显得有点复杂

/**
 * 3.随机一个5位数的整数，打印这个整数，再将这个5位数的个位与万位调换位置，十位与千位调换位置，打印出新的数。
 */
public class test_03 {
    public static void main(String[] args) {
        Random rd = new Random();
        int num = 10000 + rd.nextInt(100000-10000);
        System.out.println("num = "+num);
        int num1 = num % 10;
        int num2 = num / 10 % 10;
        int num3 = num / 100 % 10;
        int num4 = num / 1000 % 10;
        int num5 = num / 10000;
        System.out.println("调换位置后打印新的数为：" + num1 + num2 + num3 + num4 + num5);
        String s = ""+num1 + num2 + num3 + num4 + num5;
        //如何将一个字符串转换成一个整数
        int m = Integer.parseInt(s);
        System.out.println(m);
}
}
//这里和上一个练习一样对于随机数范围的处理不够省力不够简便，总是习惯用for循环死循环加判断条件
//来取想要的随机数

//问题待解决：10、用户输入3个整数，将这个3个整数从大到小打印出来，怎么使用已学知识用简单快捷
//的方法来得到结果，网上查代码使用的方法大部分都是现在这个阶段没学过的，自己原本是罗列了所有
//的情况，但是如果数据多了这种方法就不再适用了，for循环能做，但是除了for循环还有其他方法吗？

四、day04：循环语句

1、for循环

/**
 * 循环:
 *  给程序一个初始值,然后给定一个判断的条件,如果符合条件就执行,每次执行完毕之后,对程序下次
 *  执行的条件做出改变.如果不符合条件就不执行.
 * 语法:
 *  for(初始化条件表达式;条件表达式;控制条件表达式){
 *      程序执行的循环内容;
 *  }
 *  初始化条件表达式:定义程序从什么时候开始执行
 *  条件表达式:程序在什么条件下结束
 *  循环内容:程序执行的主要内容
 *  控制条件表达式:对程序执行的条件进行修改
 *  执行过程:
 *      1、执行初始化条件表达式,控制条件开始执行的内容,这里一般都是定义一个开始的变量,并且只执行
 *         一次
 *      2、执行条件表达式,如果条件表达式符合,就执行循环体,不符合就结束循环
 *      3、执行循环的主要内容.可以定义变量,可以是分支语句,可以是循环,可以是输入,随机数...
 *      4、执行控制条件表达式,对程序下一次执行的内容进行修改
 *      5、回到第二步
 *  写题的时候注意思路,一步步分析,一步步完成
 */

//觉得有代表意义的代码，对于分支语句的使用和循环嵌套的使用，对于问题的分析和具体处理
/**
 * 输入出生年月日，计算来到这个世界多少天了
 * 1、你出生的月份不能加整个月
 * 2、你出生的年份不能加整年
 * 3、计算从你出生的年份到2023年之间一共有多少天，不包含2023年
 * 整年整年计算的时候要区分平年和闰年
 * 4、2023年不能算整年，2023年2月不能加整月
 */
public class Demo_04 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入你的出生年月日，用空格隔开：");
        int year = sc.nextInt();
        int month = sc.nextInt();
        int day = sc.nextInt();
        System.out.println("请输入当前年月日，用空格隔开：");
        int y = sc.nextInt();
        int m = sc.nextInt();
        int d = sc.nextInt();
        //定义变量sum为总天数
        int sum = 0;
        //先判断输入的月份是几月，计算这个月出生日期离这个月还还剩下多少天
        //年份分为闰年，平年，具体到月份就是大小月和平月区分
        if (month == 1 || month == 3 || month == 5 || month == 7 || month == 8 || month == 10 || month == 12) {
            //后面加1是算上了出生这一天
            sum = 31 - day + 1;
        } else if (month == 4 || month == 6 || month == 9 || month == 11) {
            sum = 30 - day + 1;
        } else if (month == 2) {
            if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0) {
                sum = 29 - day + 1;
            } else {
                sum = 28 - day + 1;
            }
        }
        //你出生那年还剩下几个月，每个月有几天
        //你出生的那个月已经不算了，这一年剩下的日期，从你出生的下个月开始算
        //这里如果直接使用month进行判断的话，相当于后面的月份都和这个月的天数一样
        //这里需要用i来进行后续月份天数的计算
        for (int i = month + 1; i <= 12; i++) {
            if (i == 1 || i == 3 || i == 5 || i == 7 || i == 8 || i == 10 || i == 12) {
                sum = sum + 31;
            } else if (i == 4 || i == 6 || i == 9 || i == 11) {
                sum = sum + 30;
            } else if (i == 2) {
                if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0) {
                    sum = sum + 29;
                } else {
                    sum = sum + 28;
                }
            }
        }
        //先去出生那年和当前这一年计算年份的时间
        for (int i = year+1; i < y; i++){
            if(i % 4 == 0 && i % 100 != 0 || i % 400 == 0){
                sum+=366;
            }else{
                sum+=365;
            }
        }
        //用相同的方法，通过设置for循环不同的初始化条件表达式和条件表达式
        //来实现循环的不同功能
        for (int i = 1; i < m; i++) {
            if (i == 1 || i == 3 || i == 5 || i == 7 || i == 8 || i == 10 || i == 12) {
                sum = sum + 31;
            } else if (i == 4 || i == 6 || i == 9 || i == 11) {
                sum = sum + 30;
            } else if (i == 2) {
                if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0) {
                    sum = sum + 29;
                } else {
                    sum = sum + 28;
                }
            }
        }
        sum = sum + d;
        System.out.println("从"+year+"年"+month+"月"+day+"日到"+y+"年"+m+"月"+d+"日"+"一共"+sum+"天");
    }
}

2、while循环

/**
 * while循环
 * 语法:
 *  初始化条件表达式;
 *  while(条件表达式){
 *      循环体;
 *      控制条件表达式;
 *  }
 *  执行过程:
 *      1、初始化条件表达式,确定程序从什么时候开始执行,只执行一次
 *      2、执行条件表达式进行判断,如果是true就执行语句,false就不执行
 *      3、执行循环体
 *      4、执行控制条件表达式对条件做出改变
 *      5、回到第二步
 */

3、do...while循环

/**
 * do...while...循环
 * 语法:
 *  初始化条件表达式;
 *  do{
 *      循环体;
 *      控制条件表达式;
 *  }while(条件表达式);
 *
 * 执行过程:
 *  1、执行初始化条件表达式,控制程序从什么时候开始执行
 *  2、执行循环体
 *  3、执行控制条件表达式
 *  4、执行条件表达式进行判断,如果是true就继续执行第二步,如果是false,就不执行
 *
 *  特点:无论是否符合条件都至少执行一次,先执行后面改变条件之后再判断
 */

4、死循环

/**
 * 死循环
 * 没有停止的条件
 * 死循环我们要避免,一般用在我们不知道程序要执行多少次的情况下
 * 我们使用死循环的时候一般要使用分支语句,分支语句的条件里面必须有break,让循环停止
 */
public class Demo_07 {
    public static void main(String[] args) {
        /*for(;;){
            System.out.println("for循环的死循环");
        }*/

        /*for(int i = 0; ;i++){
            System.out.println("i = " + i);
        }*/

        /*while(true){
            System.out.println("111");
        }*/
    }
}

5、截断循环

/**
 * 截断循环
 * break:当一层循环结束循环.当有两层循环的时候,结束内层循环
 * continue:跳过当前的循环
 */
public class Demo_08 {
    public static void main(String[] args) {
        for(int i = 0; i < 10; i++){
            if(i == 5){
                System.out.println("i = " + i);
                //break;//将循环停止掉
                //continue;//当执行到该条件的时候跳过本次循环
            }else{
                System.out.println("i = " + i);
            }
        }
    }
}

6、练习问题：

/**
 * 1、输入一批整数，使用循环求出最大值与最小值，输入0时结束。
 */
public class Test_01 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int max = 0, min = 0,number = 0;
        while(true){
            int a1 = sc.nextInt();
            if (number == 0) {
                max = a1;
                min = a1;
                number++;
            }
            if (a1 == 0) {
                break;
            }
            if (a1 > max) {
                max = a1;
            }
            if (min >= a1) {
                min = a1;
            }
        }
        System.out.println("最大的数为：" + max);
        System.out.println("最小的数为："+ min);
    }
}

//个人觉得这个题比较经典，因为要处理几个变量之间的关系
//思路：应该在循环里面不停改变总金额来实现对所有变量的处理，
// 加高难度应该是再往里面加变量，如瓶盖，之前做过类似的题目，把瓶盖也考虑在里面
// 中心解题思想应该是，加两个标识赋初值为0，一个为瓶子数量，一个为可以购买的瓶数
//  总金额除以单价得到空瓶子数量，把这个数量赋给可以购买的瓶数，再对总金额进行求余处理，
//  把求余的金额加上空瓶的数量便是新的总金额，通过死循环来不同更新各个数据，最后进行判断，当
//总金额不再大于3的时候已经不能再进行购买了，循环结束
/**
 * 2、给20块钱买可乐，每瓶可乐3块钱，喝完之后退瓶子可以换回1块钱，问最多可以喝到多少瓶可乐
 */
public class Test_02 {
    public static void main(String[] args) {
        int num = 0,number = 0;//瓶子数
        int money = 20;//总金额
        for (;;) {
            num = money/3;
            number+=num;
            money = money%3;
            money =money+num;
            if (money<3){
                break;
            }
            //1.num = 6,money = 2,money = 8
            // 2.num = 2,money = 2,money = 4
            //3.num = 1,money = 1,money = 2
        }
        System.out.println("最多能喝到："+number+"瓶饮料");
    }
}

//对分支和循环的应用
/**
 * 10、玩游戏强化装备，
 * 4级以下100%成功
 * 从4强化到5有70%概率成功，30%不成功。
 * 从5强化到6有50%概率成功，50%不成功。当不成功时有5%的概率降为4，95%不变；
 * 从6强化到7有35%概率成功，65%不成功。当不成功时有10%的概率降为5，90%不变；
 * 从7强化到8有25%概率成功，75%不成功。当不成功时有20%的概率降为6，80%不变；
 * 从8强化到9有10%概率成功，90%不成功。当不成功时有30%的概率降为7，70%不变；
 * 从9强化到10有5%概率成功，95%不成功。当不成功的时候有50%的概率降为8，再50%不变。
 * 用户输入装备等级，开始强化
 */
public class Test_10 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        Random rd = new Random();
        int num = rd.nextInt(100);
        int num1 = rd.nextInt(100);
        while (true) {
            System.out.println("请选择是否强化装备，1：继续强化，2：停止强化");
            int number = sc.nextInt();
            if (number==1) {
                System.out.println("请您输入装备等级进行强化：");
                int lv = sc.nextInt();
                System.out.println("当前装备等级：" + lv);
                switch (lv) {
                    case 1:
                    case 2:
                    case 3:
                        lv += 1;
                        System.out.println("强化成功，当前等级为" + lv);
                        break;
                    case 4:
                        if (num < 70) {
                            lv += 1;
                            System.out.println("强化成功，当前等级为" + lv);
                            break;
                        }
                    case 5:
                        if (num < 50) {
                            lv += 1;
                            System.out.println("强化成功，当前等级为" + lv);
                            break;
                        } else {
                            if (num1 < 5) {
                                lv -= 1;
                                System.out.println("强化失败，当前等级为" + lv);
                                break;
                            }
                        }
                    case 6:
                        if (num < 35) {
                            lv += 1;
                            System.out.println("强化成功，当前等级为" + lv);
                            break;
                        } else {
                            if (num1 < 10) {
                                lv -= 1;
                                System.out.println("强化失败，当前等级为" + lv);
                                break;
                            }
                        }
                    case 7:
                        if (num < 25) {
                            lv += 1;
                            System.out.println("强化成功，当前等级为" + lv);
                            break;
                        } else {
                            if (num1 < 20) {
                                lv -= 1;
                                System.out.println("强化失败，当前等级为" + lv);
                                break;
                            }
                        }
                    case 8:
                        if (num < 10) {
                            lv += 1;
                            System.out.println("强化成功，当前等级为" + lv);
                            break;
                        } else {
                            if (num1 < 30) {
                                lv -= 1;
                                System.out.println("强化失败，当前等级为" + lv);
                                break;
                            }
                        }
                    case 9:
                        if (num < 5) {
                            lv += 1;
                            System.out.println("强化成功，当前等级为" + lv);
                            break;
                        } else {
                            if (num1 < 50) {
                                lv -= 1;
                                System.out.println("强化失败，当前等级为" + lv);
                                break;
                            }
                        }
                    case 10:
                        System.out.println("您的装备已满级，不需要强化！");
                        break;
                    default:
                        System.out.println("您输入的装备等级数有误，请重新输入");
                }
            }
            if (number ==2) {
                break;
            }
        }
    }
}

五、day05：循环和数组

1、关于循环的应用：打印九九乘法表、

//关于for循环运用的经典题目
/**
 * 九九乘法表
 * 一共有九行，一共有九列
 * 每行的元素个数和行数是有关系的：元素个数根据行数进行一次增加
 */
public class Demo_01 {
    public static void main(String[] args) {
        //一个语句块中不能出现相同名称的变量
        //外层循环，控制行数
        // 初始化条件表达式：程序从什么时候开始
        //条件表达式：程序到什么时候结束
        //控制条件表达式：程序做什么样的改变
        for(int i = 1;i <= 9;i++){
            //内层循环控制每行打印的个数
            //初始化条件表达式：1
            //条件表达式：每行打印的个数等于行数
            //控制条件表达式：+1
            for (int j = 1;j <= i;j++){
                //j每行打印的元素个数，打印完一行之后进行换行
                System.out.print(j + "x" + i + "=" +(j*i) + " ");
            }
            System.out.println("\n");
        }
    }
}

/**
 * 打印范围内的质数
 * 什么是质数？只能被1和它本身整除的数叫质数
 * 比如：5 只能被1 和 5整除 质数
 * 25 能被1、5、25整除，叫和数
 * 判断质数的思想：
 * 拿2到n-1之间的元素和n进行求余运算，如果n被整除了，没有余数了，就不是质数
 * 如果一直有余数，那么这个数就是质数
 */
public class Demo_03 {
    public static void main(String[] args) {
        int index = 0;
        for (int i = 2; i <= 1000; i++) {
            //默认所有的数都是质数，然后拿2~n-1之间的元素和n进行求余运算
            //如果被某一个元素除尽了，那么就说明这个数不是质数，就将这个标志改为false
            //定义一个标识，用来标志所有的数都是质数
            boolean flag = true;
            /**
             * 求余运算的循环
             * 从什么时候开始执行？ 2
             * 到什么时候结束？i-1结束
             * 每次做什么样的改变？j++
             */
            /*Math.sqrt(i):对数据进行开方操作*/
            for (int j = 2; j <= Math.sqrt(i); j++) {
                //求余运算：如果余数为0了说明i被除尽了，说明还有其他的因数
                //i就不是一个质数，那么就将标识符改成false
                if (i % j == 0) {
                    flag = false;
                    break;//当一个数已经被除尽的之后，其余求余运算就不需要往下执行了，直接结束内层循环
                }
            }
            //因为if的括号中条件是一个boolean类型的值，那么现在正好flag是一个boolean类型
            //当内层循环进行取余判断为true即能被除尽且没有余数时，说明这个数不是质数，要改变flag的状态
            //当内层循环进行取余判断为false即不能被除尽且有余数时，说明这个数是质数，不需要改变flag的状态 flag任然为true 再进行输出
            if (flag) {
                index++;
                System.out.println("i = " + i);
            }
        }
        System.out.println("一共有" + index + "个质数");
    }
}

2、关于标识的理解和运用

(1)理解：标识多用于for循环嵌套，死循环作为结束条件用得较多，还有作为最后得到的目标值输出用得也较多；

(2)数据类型：通常是布尔类型和整数类型（int型为主）；

(3)应用：求和运算在循环外定义的初始值为0或其他值的变量，双层嵌套for循环，for循环打印最大值最小值问题等等

3、数组：

(1)数组的基本概念和运用

/**
 * 数组：
 * Array
 * 在计算机的内存中开辟连续的内存空间，用来存储元素的集合
 * 1、数组中存储的元素的数据类型是相同的，由定义的时候数组的数据类型决定
 * 2、数组中存储元素的时候如果使用动态初始化，我们只能存储指定的个数，如果想要存储得更多，
 *    就要手动扩容，重新定义一个数组，将原来数组中的元素存储到新的数组中
 *
 * 动态初始化：
 *     定义了数组，但是没有往数组中存储元素，现在空间已经有了，我们所有的空间都赋了初始值
 *     数据类型[] 数组名 = new 数据类型[数组长度或者元素个数]
 * 不同数据类型的初始值：
 *      数据类型                  初始值
 *      byte short int long       0
 *      float double              0.0
 *      char                     /u0000
 *      boolean                  false
 *      String                    null
 *
 * 静态初始化：
 *     当我们定义数组的时候直接给定数组中的元素，存储了多少元素，数组的长度就是几
 *     1、数据类型[] 数组名 = new 数据类型[] {元素1，元素2，元素3...}
 *     2、数据类型[] 数组名 = {元素1，元素2，元素3...}
 *
 * 如何获取数组长度：数组.length
 * 如何获取数组中的元素：数组名[数组元素下标]：数组元素下标从0开始
 * 如何给数组中的元素进行赋值：数组名[数组下标] = 值;
 */
public class Demo_01 {
    public static void main(String[] args) {
        //动态初始化：
        //数据类型[] 数组名 = new 数据类型[数组长度或者元素个数];
        //定义了一个int类型的数组，数组的长度为5
        int[] arr = new int[5];//[0,0,0,0,0]
        arr[3] = 100;//[0,0,100,0,0]

        //静态初始化：
        //1、数据类型[] 数组名 = new 数据类型[] {元素1，元素2，元素3...}
        String[] name = new String[]{"张三","李四","王五"};
        System.out.println(name[2]);

        //2、数据类型[] 数组名 = {元素1，元素2，元素3...}
        double[] price = {39.9,69.9,9.9,89.9,288};

        //如何获取数组的长度：数组名.length
        int len = name.length;//length是一共属性，因为后面没有加括号
        System.out.println("数组在内存中的地址："+name);
        System.out.println("name的长度为："+len);

        String s = "今天星期五，明天休息，今晚上晚自习";
        System.out.println("字符串的长度："+s.length());//获取到字符串长度的是一个方法

    }
}

(2)数组和for循环的组合使用，foreach和普通for循环的区别和用法

/**
 * ArrayIndexOutOfBoundsException:抛出以表示使用非法索引访问数组。索引为负数或大于或等于
 * 数组的大
 */
public class Demo_02 {
    public static void main(String[] args) {
        String[] name = {"张无忌", "张三丰", "张翠山", "赵敏", "谢逊"};
        //for循环
        //1、初始化条件表达式：从数组下标0开始
        //2、条件表达式：到数组长度 -1处理
        //3、控制条件表达式：每次做加1处理
        for (int i = 0; i < name.length - 1; i++) {
            System.out.print(name[i]+" ");
        }
        System.out.println();
        System.out.println("===============");
        //foreach:增强for循环  我们可以获取到元素，但是不能获取到下标，但是可以自动对数组
        //进行遍历赋值到变量
        /**
         * 语法：
         * for(数据类型 变量名 ：数组){
         *     对变量进行处理;
         * }
         */
        for (String n: name) {
            System.out.print(n+" ");
        }
        //使用了java内置类Array中的toString方法将数组中的元素内容拼接成一个不可改变的
        //字符串
        System.out.println(Arrays.toString(name));
    }
}

(3)数组的简单运用

/**
 * 1、现在由用户手动输入数组中元素的个数，然后使用随机数进行赋值，赋值范围自己定义
 * 2、定义一个长度为20的数组，然后使用随机数对数组进行赋值操作，范围是100~200之间
 * 3、将100~200之间的质数找出来，存储到一个数组中
 */
//第三题：
//采用的是先规定一个数组长度大于目标质数个数的数组，再确定符合条件的质数将质数存储到数组中
//这样一来，数组中就存储了全部的质数，再定义一个新数组，将长度设置为之前每次质数存储到数组
//中时执行的index++操作得到的index的值，进行for循环将原数组中的非0元素赋值到新数组中
//这样解决问题要先经过一次循环计算出质数的个数，有没有一种方法或者工具能在每次得到质数便把
//质数存储到一个内存空间里面或者说怎么确定数组长度和怎么将得到的每个质数在每次得到质数的循环里给数组
public class Demo_03 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        Random rd = new Random();
        System.out.println("=========第一题============");
        System.out.println("请输入数组元素个数的值");
        int num = sc.nextInt();
        int[] arr = new int[num];
        for (int i = 0; i <= arr.length - 1; i++) {
            arr[i] = rd.nextInt(100);
            System.out.println("第" + (i + 1) + "个数组元素为：" + arr[i]);
        }
        System.out.println("现在的数组是：" + Arrays.toString(arr));


        System.out.println("=========第二题============");
        int[] arr1 = new int[20];
        for (int i = 0; i <= arr1.length - 1; i++) {
            arr1[i] = 100 + rd.nextInt(100);
        }
        for (int i : arr1) {
            System.out.println(i + " ");
        }
        System.out.println("长度为20的数组为：" + Arrays.toString(arr1));

        /**
         * 1、进行质数的个数判断，然后存储到一个变量中
         * 2、新建一个数组，然后将累加的数组中的元素个数作为数组的长度
         * 3、再执行一次质数的处理然后将质数存进去
         *
         * 1、首先定义一个长度超过预期值的数组
         * 2、然后查找所有的质数并且对数组中的元素进行赋值
         * 3、将数组中补位0 的元素放在一个新的数组中
         */
        //定义一个长度为100的数组来存储质数
        System.out.println("===================第三题====================");
        int[] arr3 = new int[100];
        int index1 = 0;
        //查找范围内的质数并且将其放在数组中
        //外层循环
        for (int i = 100; i <= 200; i++) {
            boolean flag = true;
            for (int j = 2; j <= Math.sqrt(i); j++) {
                if (i % j == 0) {
                    flag = false;
                    break;
                }
            }
            if (flag){
                arr3[index1] = i;
                index1++;
            }
        }
        int[] arr4 = new int[index1];
        //判断有多少个元素不为0，
        for (int i = 0; i < arr4.length; i++){
            arr4[i] = arr3[i];
        }
//        for (int i = 0; i < arr3.length; i++){
//            if (arr3[i]!=0){
//                arr4[index1] = arr3[i];
//                index++;
//            }
//        }
        System.out.println(Arrays.toString(arr4));
        System.out.println(Arrays.toString(arr3));
       
    }
}

/**
 * 定义三个数组
 * 商品名称：[巧克力，牛奶，瓜子，花生，八宝粥，可乐，雪碧，辣条]
 * 商品价格：[8，5，6，7，4，3，3，5]
 * 商品库存量：[100，20，40，50，80，30，70，80]
 * 模拟用户购买商品的过程
 * 1、首先向用户展示有什么商品
 * 2、问用户需要什么
 * 3、判断是否有
 * 4、有的话告诉用户多少钱，没有的话告诉用户出门左转隔壁看看
 * 5、用户输入购买量之后判断库存是否充足
 * 6、如果充足可以实现购买，如果不足，去隔壁看看
 * 7、打印用户购买的数量和价格以及总价
 */
public class Demo_04 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String[] arr1 = {"巧克力", "牛奶", "瓜子", "花生", "八宝粥", "可乐", "雪碧", "辣条"};
        int[] arr2 = {8, 5, 6, 7, 4, 3, 3, 5};
        int[] arr3 = {100, 20, 40, 50, 80, 30, 70, 80};
        while (true) {
            System.out.println("请输入0（继续购物）或1（退出）");
            int number = sc.nextInt();
            if (number == 0) {
                System.out.println("==============欢迎光临啥也没有店铺！！！！================");
                System.out.println("商品有" + Arrays.toString(arr1) + "请问您需要什么？");
                System.out.println("请输入您想要购买的商品名称：");
                String str1 = sc.next();
                int count = 0;
                for (int i = 0; i < arr1.length; i++) {
                    if (str1.equals(arr1[i])) {
                        count++;
                        System.out.println("您想要购买的商品单价" + arr2[i]);
                        System.out.println("请输入您想要购买的数量：");
                        int num = sc.nextInt();
                        if (num > 0 && num <= arr3[i]) {
                            System.out.println("您购买商品为:" + arr1[i] + "数量为:" + num + " " + "需要付:" + (num * arr2[i]) + "元钱");
                            arr3[i] -= num;
                            if (arr3[i] != 0) {
                                System.out.println(arr1[i] + "还剩余" + arr3[i]);
                            } else {
                                System.out.println(arr1[i] + "已经没了，你挑的嘛！偶像！");
                            }
                            break;
                        } else {
                            System.out.println("商品数量不够，麻烦去隔壁看看");
                        }
                    }
                }
                if (count == 0) {
                    System.out.println("没有该商品，麻烦去隔壁看看");
                }
                System.out.println("=============================");
            } else if (number == 1) {
                break;
            } else {
                System.out.println("您输入的序号有误，请重新输入");
            }
        }
    }
}

(4)数组---冒泡排序

//手写，csdn界面输入
public class Demo_05{
      public static void main(String[] args){
            //定义一个数组
            int[] arr = { 68 , 55 , 79 , 32 , 11 , 77 , 89 , 45 , 99 , 12} ;
            //输出这个数组便于对后面的数组进行对比
            System.out.println(Arrays.toString(arr))
            //外层循环记录比较的轮数
           for(int i = 1; i < arr.length; i++){
              //内层循环记录每轮比较的次数
               for(int j = 0; j < arr.length - i;j++){
                  //判断前面一个数组元素和后面一个数组元素的大小，大则交换，小不处理
                   if(arr[j] >= arr[j+1]){
                       int temp = arr[j+1];
                       arr[j+1] = arr[j];
                       arr[j] = temp;
                      }
                 }
            } 
           //输出排序后的数组，验证是否排序成功
            System.out.println(Arrays.toString(arr));       
      }
}

//复制代码
/**
 * 冒泡排序：
 * 元素之间两两相比较，如果前面的数比后面的大，两个数据就交换位置，然后拿着较大
 * 的数和下一个数进行比较，每一次比较找出本轮的最大值，每轮的最大值不参与下一轮比较
 * 原数据     68  55  79  32  11  77  89  45  99  12   比较次数
 * 第一轮     55  68  32  11  77  79  45  89  12 [99]     9
 * 第二轮     55  32  11  68  77  45  79  12 [89] 99      8
 * 第三轮     32  11  55  68  45  77  12 [79] 89  99      7
 * 第四轮     11  32  55  45  68  12 [77] 79  89  99      6
 * 第五轮     11  32  45  55  12 [68] 77  79  89  99      5
 * 第六轮     11  32  45  12 [55] 68  77  79  89  99      4
 * 第七轮     11  32  12 [45] 55  68  77  79  89  99      3
 * 第八轮     11  12 [32] 45  55  68  77  79  89  99      2
 * 第九轮     11 [12] 32  45  55  68  77  79  89  99      1
 *
 */
public class Demo_05 {
    public static void main(String[] args) {
        int[] arr = {68, 55, 79, 32, 11, 77, 89, 45, 99, 12};
        System.out.println("原本的数组为："+Arrays.toString(arr));
        //外层循环表示比较的轮数,因为最后一轮剩下一个数据了，自己不需要和自己比较
        for (int i = 1; i < arr.length; i++) {
            //内层循环控制每轮比较的次数
            for (int j = 0; j < arr.length - i; j++) {
                //判断两个数的大小，如果前面的数比后面的数大，就将两个数值交换位置
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];//把大的数据放在中间变量里面
                    arr[j] = arr[j+1];//把小的数给原本大的数的位置，也就是跑到前面去了
                    arr[j+1] = temp;//把大的数据放在原本小一点的数所放的位置
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}

4、练习：

/**
 * 2、将一组数组逆序存储到新数组中
 */
public class Test_02 {
    public static void main(String[] args) {
        int[] arr1 = {5,4,6,3,2,8,9};
        System.out.println("当前数组为："+Arrays.toString(arr1));
        for (int start = 0,end = arr1.length-1; start<=end; start++,end--) {
            int temp =arr1[start];
            arr1[start] = arr1[end];
            arr1[end] = temp;
        }
        System.out.println("新数组为："+Arrays.toString(arr1));
    }
}

二分法查找初运用

/**
 * 4、使用二分法从一组数中找出目标数字
 */
public class Test_04 {
    public static void main(String[] args) {
        int[] arr = {1, 8, 5, 9, 7, 6, 2};
        System.out.println("原数组为" + Arrays.toString(arr));
        Arrays.sort(arr);
        System.out.println("排序后的数组为" + Arrays.toString(arr));//1，2，5，6，7，8，9
        Scanner sc = new Scanner(System.in);
        System.out.println("请您输入想要寻找的数字：");
        int num = sc.nextInt();
        //使用二分法查找
        boolean flag = true;
        int start = 0, end = arr.length - 1;
        while (start <= end) {
            int number = (start + end) / 2;
            if (num == arr[number]) {
                System.out.println("成功找到目标数组，该数位于数组的第" + (number + 1) + "个元素");
                flag = false;
                break;
            } else if (num < arr[number]) {
                end = number - 1;
            } else {
                start = number + 1;
            }

        }
        if (flag){
            System.out.println("没有找到目标数，或目标数不存在");
        }
    }
}

六、周总结

1、收获：

学起来时间总是过得非常快的，不知不觉一个周就完了，这个周学了很多东西，很多以前没注意的细节和相关知识点的具体应用都注意到了，比如以前学过的原码补码反码的知识加深了印象，二进制十进制的转换，相关数据类型的具体取值范围，在每日的练习题中大部分能独立完成，虽然每次都是晚自习快下，甚至已经下了晚自习才堪堪完成，有时候还会遇到当时没想出来怎么做的题目，第二天会看一看头一天的内容，因为是学过的基本上都是一扫而过

2、不足：

对于同时寻找最大值和最小值的这类题型还不怎么会，不知道怎么处理两者和其标识的关系，希望这类题型自己能放学后多看看，往往自己做题和老师讲题的方法不一致，有时候自己的做法有点复杂不够简洁，希望多练能养成好的编程思维；老师提到的每天刷两道算法题没能做到，因为自己做完练习题就没有多余的时间了，回到宿舍又大概率不会学了，最多回宿舍了看一下今天学过的内容了

（如果自习室能一直开放我觉得我能干到11点😄😄）

下周继续努力！！！