Java语言跨平台原理（理解）

1.主流的平台有Windows、macOS、Linux，移动平台有IOS、Android
2.Java程序无法跨平台直接运营，是依赖于JVM实现的跨平台。每个平台都有一个自己特有的JVM，正是由于JVM的不跨平台才保障了Java的跨平台。
3.Java提倡的是“一处编译处处运行”。但是大家要注意良好的编码习惯，要不然会变成“一处编译处处调试”，这个随着后面的学习，慢慢会介绍给大家。

JRE和JDK（记忆）
    JVM:    java虚拟机，java编译后的字节码文件运行的平台

    JRE:    java运行环境，包含了Jvm和核心类库

    JDK:    Java开发环境，包含了JRE和开发工具，开发工具包括但不仅限于Javac和java

    JDK:    JRE+开发工具=JVM+核心类库+开发工具
常用DOS命令（应用）

在接触集成开发环境之前，我们需要使用命令行窗口对java程序进行编译和运行，所以需要知道一些常用DOS命令。
    1、打开命令行窗口的方式：win + r打开运行窗口，输入cmd，回车。
    2、常用命令及其作用





注释（理解）
注释是对代码的解释和说明文字，可以提高程序的可读性，因此在程序中添加必要的注释文字十分重要。Java中的注释分为三种：
单行注释。单行注释的格式是使用//，从//开始至本行结尾的文字将作为注释文字。

~~~java
// 这是单行注释文字
~~~

多行注释。多行注释的格式是使用/* 和 */将一段较长的注释括起来。
~~~java
/*
这是多行注释文字
这是多行注释文字
这是多行注释文字
*/
注意：多行注释不能嵌套使用。
~~~
文档注释。文档注释以`/**`开始，以`*/`结束。


关键字（理解）
关键字是指被java语言赋予了特殊含义的单词。

关键字的特点：
​    1.关键字的字母全部小写。
​    2.常用的代码编辑器对关键字都有高亮显示，比如现在我们能看到的public、class、static等。
常量（应用）
    常量：在程序运行过程中，其值不可以发生改变的量。

    Java中的常量分类：

​    字符串常量  用双引号括起来的多个字符（可以包含0个、一个或多个），例如"a"、"abc"、"中国"等

​    整数常量  整数，例如：-10、0、88等

​    小数常量  小数，例如：-5.5、1.0、88.88等

​    字符常量  用单引号括起来的一个字符，例如：'a'、'5'、'B'、'中'等

​    布尔常量  布尔值，表示真假，只有两个值true和false

​    空常量  一个特殊的值，空值，值为null

    除空常量外，其他常量均可使用输出语句直接输出。
数据类型（记忆、应用）

计算机存储单元

我们知道计算机是可以用来存储数据的，但是无论是内存还是硬盘，计算机存储设备的最小信息单元叫“位（bit）”，我们又称之为“比特位”，通常用小写的字母”b”表示。而计算机中最基本的存储单元叫“字节（byte）”，

通常用大写字母”B”表示，字节是由连续的8个位组成。

除了字节外还有一些常用的存储单位，其换算单位如下：

1B（字节） = 8bit

1KB = 1024B

1MB = 1024KB

1GB = 1024MB

1TB = 1024GB

3.4.2 Java中的数据类型

Java是一个强类型语言，Java中的数据必须明确数据类型。在Java中的数据类型包括基本数据类型和引用数据类型两种。


数据类型:分为基本数据类型,引用数据类型两种

一.基本数据类型:  
//八种基本数据类型
1.数值型
    [整数]  byte(字节型),    short ,   int(整型) ,   long(长整型)
    [浮点型]  float,   double,
    [字符型]   char(字符型)
2.非数值型
    (布尔型)boolean   

二引用数据类型(三种):
    类(class)
    接口(interface)
    数组([])
说明：
    e+38表示是乘以10的38次方，同样，e-45表示乘以10的负45次方。
​    在java中整数默认是int类型，浮点数默认是double类型。




变量（应用）
     变量的定义
变量：在程序运行过程中，其值可以发生改变的量。
从本质上讲，变量是内存中的一小块区域，其值可以在一定范围内变化。

变量的定义格式：

数据类型 变量名 = 初始化值; // 声明变量并赋值

还可以在同一行定义多个同一种数据类型的变量，中间使用逗号隔开。但不建议使用这种方式，降低程序的可读性。

变量的使用：
通过变量名访问即可。



3.5.2 使用变量时的注意事项
1. 在同一对花括号中，变量名不能重复。
2. 变量在使用之前，必须初始化（赋值）。
3. 定义long类型的变量时，需要在整数的后面加L（大小写均可，建议大写）。因为整数默认是int类型，整数太大可能超出int范围。
4. 定义float类型的变量时，需要在小数的后面加F（大小写均可，建议大写）。因为浮点数的默认类型是double， double的取值范围是大于float的，类型不兼容。



3.6 标识符（记忆、理解）
标识符是用户编程时使用的名字，用于给类、方法、变量、常量等命名。

Java中标识符的组成规则：

​    1.由字母、数字、下划线“_”、美元符号“$”组成，第一个字符不能是数字。

​    2.不能使用java中的关键字作为标识符。   

​    3.标识符对大小写敏感（区分大小写）。

Java中标识符的命名约定：

​    1.小驼峰式命名：变量名、方法名

​    2.首字母小写，从第二个单词开始每个单词的首字母大写。

​    3.大驼峰式命名：类名

​    4.每个单词的首字母都大写。

​    5.另外，标识符的命名最好可以做到见名知意
        例如：username、studentNumber等。




3.7 类型转换（理解）
在Java中，一些数据类型之间是可以相互转换的。分为两种情况：自动类型转换和强制类型转换。

自动类型转换：
​把一个表示数据范围小的数值或者变量赋值给另一个表示数据范围大的变量。这种转换方式是自动的，直接书写即可

例如:
double num = 10; // 将int类型的10直接赋值给double类型
System.out.println(num); // 输出10.0



强制类型转换：
​把一个表示数据范围大的数值或者变量赋值给另一个表示数据范围小的变量。
范围从大到小:
    byte-short-int-long-float-double
             char-int-long-float-double

​强制类型转换格式：
目标数据类型 变量名 = (目标数据类型)值或者变量;

​    例如：
double num1 = 5.5;
int num2 = (int) num1; // 将double类型的num1强制转换为int类型
System.out.println(num2); // 输出5（小数位直接舍弃）



说明：
1.char类型的数据转换为int类型是按照码表中对应的int值进行计算的。比如在ASCII码表中，'a'对应97。
例如:
int a = 'a';
System.out.println(a); // 将输出97



2. 整数默认是int类型，byte、short和char类型数据参与运算均会自动转换为int类型。
例如:
byte b1 = 10;
byte b2 = 20;
byte b3 = b1 + b2;
// 第三行代码会报错，b1和b2会自动转换为int类型，计算结果为int，int赋值给byte需要强制类型转换。
// 修改为:
int num = b1 + b2;
// 或者：
byte b3 = (byte) (b1 + b2);


3. boolean类型不能与其他基本数据类型相互转换。
运算符&表达式
    运算符其实就是一些符号（eg:+ - * /）
表达式
    用运算符连接起来的一些式子，成为表达式。如果用算术运算符连接起来，就是算术表达式
1. 算术运算符
    + - * / %
    整数相除结果只能是整数
    %取余，结果是余数

    字符相+
    先把自己转换成int值，然后再运算，转换时的原则：按照其在计算机底层的存储值进行转换
    'A'    65
    'a'    97
    '0'    48
    自动类型提升：
    基本数据类型（boolean除外）进行算术运算时，会有自动类型提升：
    a. byte、short、char参与运算时，会自动转换成int类型，然后再进行运算
    b. 在算术表达式中，讲数据类型转换成参与运算的所有数据中的最高级别。
    （byte/short/char<int<long<float<double）

    字符串相+
    其实就是字符串的拼接
    从左往右依次执行，在遇到字符串之前，会找原有的规则进行运算。
    如果遇到了字符串，就开始进行字符串拼接。
   
    自增/自减运算符
    ++/--    变量增加/减少1
    使用：   
        单独使用    在前或在后，对运算结果没有影响
        参与运算
            自增或自减在前，先进行自增减然后再参与其他运算
            自增或自减在后，先进行其他运算，然后再进行自增减   
2.赋值运算符 =
    int i = 10;    //将10赋值给int类型的变量i
    i = i + 20;    //将i的值加上20之后，重新赋值给变量i

    复合赋值运算符
    +=、-=、*=、/=、%=
   
    i += 10;  //在结果上等同于i = (i的类型)(i +10);
    一般不建议使用强转，建议使用复合赋值运算符
3.关系运算符
    关系表达式的结果只能是boolean类型，也就是只能是true或者false
    ==、>、<、>=、<=、!=

    不要将==错写成了=
    System.out.println(i=j+k),把j的值赋值给变量i，并且输出

4. 逻辑运算符
    连接了两个及以上的关系表达式
    &、|、^、!
    & 与    并且    只要有false，结果就是false，同时为true，结果才是true
    | 或    或者    只要有true，结果就是true；同时为false，结果才是false
    ^a异或    男女关系    相同为false，不同为true
    ! 非    否定    !true = false, !false=true; !!true = true;

    短路逻辑运算符
        &&    短路与    只要遇到false，后面的关系表达式便不执行
        ||    短路或    只要遇到true，后面的关系表达式便不执行

    工作中常用的是 &&、||、!
   

5. 三元运算符
    格式：关系表达式 ? 表达式1 : 表达式2


    示例： a > b ? c : d
    执行流程：
        判断关系表达式的值
        如果该值为true，三元表达式的值就是表达式1的值
        如果该值为false，三元表达式的值就是表达式2的值
    求两个数据中，较大的数值
        变量类型 max = a > b ? a : b;




6. 键盘录入的三个步骤
    导包        import java.util.Scanner;
    创建对象    Scanner sc = new Scanner(System.in);
    接收数据    int i = sc.nextInt();


7. if语句格式1
    if(关系表达式){
        语句体   
    }
    执行流程
    1. 判断关系表达式的值
    2. 如果关系表达式的值为true，就执行语句体，然后继续执行后面的其他代码
    3. 如果关系表达式的值为false，就不执行语句体，接续执行后面的其他代码

8. if语句格式2
    if(关系表达式){
        语句体1;
    } else {
        语句体2;
    }

    执行流程：
    1. 判断关系表达式的值
    2. 如果关系表达式的值是true，执行语句体1，然后继续执行后面的其他代码
    3. 如果关系表达式的值是false，执行语句体2，然后继续执行后面的其他代码


9. if语句格式3
    if(关系表达式1){
        语句体1;
    }else if(关系表达式2){
        语句体2;
    }
    ……
    else{
        语句体n+1;
    }

    执行流程
    1. 判断关系表达式1的值，如果是true，就执行语句体1；
    2. 如果为false，就继续判断关系表达式2的值，如果关系表达式2的值是true，就执行语句体2；
    3. ……
    4. 只要有一个关系表达式的值是true，就执行对应的语句体
    5. 如果所有的关系表达式的值都是false，就执行else里面的语句体n+1



范例:判断a/b/c三个数是否相等
使用if语句结构.

    /*
        if语句结构.
    */
   
   
    public class TestScanner{
        public static void main(String []args){
            System.out.println("开始");
            //定义变量
            
            int a=10;
            int b=20;
            int c=10;
            
            //判断a和b是否相等
            if(a == b){
                System.out.println("a=b");
            }
            //判断a和c是否相等
            if(a == c){
                System.out.println("a=c");
            }
            System.out.println("结束");
        }

    }

if else

案例:输入一个数,判断是该数是奇数,还是偶数
使用if else语句结构.
/*
    奇偶数
*/

//导包
import java.util.Scanner;
public class Test{
    public static void main(String [] args){
        //接收数据
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入一个整数");
        int a =sc.nextInt();
        if(a % 2 == 0){
            System.out.println("该数是偶数");
        }else{
            System.out.println("该数是奇数");
        }
        
    }
}


if else if else
案例:从控制台输出1-7,打印对应的星期数
使用if else if else语句结构.
/*
    奇偶数
*/

//导包
import java.util.Scanner;
public class Test{
    public static void main(String [] args){
        //接收数据
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入1-7的星期数");
        int a =sc.nextInt();
        if(a  == 1){
            System.out.println("星期一");
        }else if(a  == 2){
            System.out.println("星期二");
        }else if(a  == 3){
            System.out.println("星期三");
        }else if(a  == 4){
            System.out.println("星期四");
        }else if(a  == 5){
            System.out.println("星期五");
        }else if(a  == 6){
            System.out.println("星期六");
        }else if(a  == 7){
            System.out.println("星期日");
        }else
            System.out.println("输入有误,请重新输入");
        
    }
}

案例:考试奖励案例:
使用if else if else语句结构.
/*
    考试奖励案例
*/

//导包
import java.util.Scanner;
public class Test{
    public static void main(String [] args){
        //接收数据
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入小明的成绩:");
        int a =sc.nextInt();
        if(a  >=95 && a <= 100){
            System.out.println("奖励自行车");
        }else if(a  >=90 && a <= 94){
            System.out.println("旋转木马");
        }else if(a  >=80 && a <= 89){
            System.out.println("变形金刚");
        }else
            System.out.println("挨打");
        
    }
}

循环结构(for,    whlie,    do...while)
(switch语句)

1. switch结构
switch的基本组成格式
     switch(表达式){
        case 值1:
            语句体1;
            break;
        default:
            语句体n+1;
            break;
     }
switch中break的作用
     用于结束整个switch语句的执行
switch中default的执行时机
     当表达式的值，和case给出的值，都没有匹配成功，将会执行default
switch括号中的表达式可以接收的类型
    byte，short，int，char，jdk5开始可以接收枚举，jdk7开始可以接收String
执行流程：
首先计算出表达式的值
其次，和case依次比较，一旦有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结束。
最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉。




练习1:
案例:从控制台输入1-7,输出相应的星期数1-7.
switch语句的使用
/*
    Switch语句
*/

//导包
import java.util.Scanner;
public class Test{
    public static void main(String [] args){
        System.out.println("开始");
        //接收数据
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入一个星期数(1-7):");
        int a =sc.nextInt();
        switch(a){
            case 1:
            System.out.println("星期一");
            break;
        
            case 2:
            System.out.println("星期二");
            break;
        
            case 3:
            System.out.println("星期三");
            break;
        
            case 4:
            System.out.println("星期四");
            break;
        
            case 5:
            System.out.println("星期五");
            break;
        
            case 6:
            System.out.println("星期六");
            break;
        
            case 7:
            System.out.println("星期日");
            break;
        
            default:
            System.out.println("输入有误,请重新输入");
        
        }
    }
}

练习2:
案例:春夏秋冬
switch语句case穿透的使用
/*
    Switch语句
    一年12个月,春夏秋冬
*/

//导包
import java.util.Scanner;
public class Test{
    public static void main(String [] args){
        System.out.println("开始");
        //接收数据
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入一个月份(1-12)");
        int a =sc.nextInt();
        switch(a){
        //case穿透
            case 1:
            case 2:
            case 12:
                System.out.println("冬季");
            break;
            case 3:
            case 4:
            case 5:
                System.out.println("春季");
                break;
            case 6:
            case 7:
            case 8:
                System.out.println("夏季");
            case 9:
            case 10:
            case 11:
                System.out.println("秋季");
                break;
            default:
            System.out.println("输入有误,请重新输入");
        
        }
    }
}


循环语句()
for循环语句
循环语句可以在满足循环条件的情况下，反复执行某一段代码，这段被重复执行的代码被称为循环体语句，当反复 执行这个循环体时，需要在合适的时候把循环判断条件修改为false，从而结束循环，否则循环将一直执行下去，形成死循环。
格式解释：

  * 初始化语句：  用于表示循环开启时的起始状态，简单说就是循环开始的时候什么样
  * 条件判断语句：用于表示循环反复执行的条件，简单说就是判断循环是否能一直执行下去
  * 循环体语句：  用于表示循环反复执行的内容，简单说就是循环反复执行的事情
  * 条件控制语句：用于表示循环执行中每次变化的内容，简单说就是控制循环是否能执行下去




执行流程：

  ①执行初始化语句
  ②执行条件判断语句，看其结果是true还是false
  ​             如果是false，循环结束
  ​             如果是true，继续执行
  ③执行循环体语句
  ④执行条件控制语句
  ⑤回到②继续




练习1.
案例:从1输出到5
for循环语句的使用
public class ForDemo{
    public static void main(String[] args){
        //for循环
        for(int i=1;i<=5;i++){
            System.out.println(i);
        }
    }
   
}


练习2.
案例:从1输出到5,从5输出到1
for循环语句的使用
public class ForDemo{
    public static void main(String[] args){
        //for循环
        for(int i=1;i<=5;i++){
            System.out.println(i);
        }
            System.out.println("-----------------");
        for(int j=5;j >=1;j--){
            System.out.println(j);
        
        }
    }
   
}

练习3:
案例:1-5之间的和
重点:理解            +=用法
public class ForTest{
        //for循环求1-5的和
    public static void main(String[] args){
        //定义变量
        int sum=0;
        //for循环语句
        for(int i=1;i<=5;i++){
            sum +=i;
                       /*
                           sum += i; sum=sum+i;
                               第一次:sum=sum+i; sum= 0 + 1 = 1;
                               第二次:sum=sum+i; sum = 1 + 2 = 3;
                               第三次:sum=sum+i; sum = 3 + 3 = 6;
                               第四次:sum=sum+i; sum = 6 + 4 = 10;
                               第五次:sum=sum+i; sum = 10 + 5 = 15;
                       */
        }
        System.out.println("1-5的和是:" +sum);
            
    }
   
}

42.求偶数和
public class ForTest{
        //for循环求1-100之间的偶数和
    public static void main(String[] args){
        //定义变量
        int sum=0;
        //for循环语句
        for(int i=1;i<=100;i++){
            if(i % 2 == 0){
                sum +=i;
            }        
    }
        System.out.println("1-100的偶数和是:" +sum);
    }
}

  练习4.
         案例:在控制台输出所有的水仙花数
for循环的运用
说明:几位数字就除以单位在进行取余(%10)即可
水仙花数:是一个三位数,数字的各个位数的立方和.列如:371=3^3+7^3+1^3=371
public class ForTest{
         //水仙花案例   
        //for循环输出所有的水仙花数
    public static void main(String[] args){
        //定义变量
        //for循环语句从100开始-999结束
        for(int i=100;i<=999;i++){
            //在计算之前获取三位数中每个位子上的值
            int ge=i%10;
            int shi=i/10%10;
            int bai=i/100%10;
            //判断条件是将三位数中的每个数值取出来,计算立方和后与原始数据是否相等
            if(ge*ge*ge+shi*shi*shi+bai*bai*bai ==i){
                System.out.println(i);
            }        

    }
    }
}


练习5.
for循环的运用
案例:统计水仙花的个数:
public class TestSix{
        //统计案例
        //计算一共有几个水仙花数
    public static void main(String[]args){
        //定义变量,存储水仙花数的个数
            int count=0;
            //for循环输出所有的水仙花数
            for(int i=100;i<=999;i++){
                //计算每个位置上的值
                int ge=i%10;
                int shi=i/10%10;
                int bai=i/100%10;
               
                //判断条件是将三位数中的每个数值取出来,计算立方和后是否与原数相等
                if(ge*ge*ge+shi*shi*shi+bai*bai*bai == i){
                    count++;
                }
               
            }
            System.out.println(count);
    }
}



while循环语句
     while循环完整格式：

  初始化语句;
  while (条件判断语句) {
      循环体语句;
      条件控制语句;
  }


* while循环执行流程：

  ①执行初始化语句

  ②执行条件判断语句，看其结果是true还是false
  ​             如果是false，循环结束
  ​             如果是true，继续执行
  ③执行循环体语句

  ④执行条件控制语句
  ⑤回到②继续


练习1.
案例:输出五次HelloWorld
while语句的运用
public class TestSix{
        //While语句
        //输出5次HelloWord
    public static void main(String[]args){
        //while循环
        int i=1;
        while(i<=5){
            System.out.println("HelloWorld");
            i++;
        }
    }
}


练习2.
案例:珠穆朗玛峰
珠穆朗玛峰(8844.43米=8844430毫米),一张白纸厚度是0.1毫米要折叠多少次,可以叠到珠穆朗玛峰的高度
while语句的运用
public class TestSix{
        //While案例:珠穆朗玛峰
        //珠穆朗玛co峰(8844.43米=8844430毫米),一张白纸厚度是0.1毫米要折叠多少次,可以叠到珠穆朗玛峰的高度
    public static void main(String[]args){
        //定义变量,存储折叠次数
        int count=0;//折叠次数
        //while循环
        double paper=0.1;//纸张厚度
        int zf=8844430;//珠峰高度
        while(paper<=zf){
                //循环的执行过程中纸张的厚度要加倍.
                paper*=2;
                //在循环中执行累加,对应折叠了多少次
                count++;
            }
            System.out.println("需要折叠"+count+"次");
    }
}


do...while循环语句
完整格式：
  初始化语句;
  do {
      循环体语句;
      条件控制语句;
  }while(条件判断语句);

执行流程：

  ① 执行初始化语句

  ② 执行循环体语句

  ③ 执行条件控制语句

  ④ 执行条件判断语句，看其结果是true还是false

  如果是false，循环结束

  如果是true，继续执行

  ⑤ 回到②继续



练习1.
案例:利用do while输出5次"HelloWorld"
do while语句的运用
public class DoWhile{
    public static void main(String[]args){
        int i=1;
        do{
            System.out.println("Helloworld");
            i++;
        }while(i<=5);
    }
}



三种循环的区别            
三种循环的区别
  * for循环和while循环先判断条件是否成立，然后决定是否执行循环体（先判断后执行）
  * do...while循环先执行一次循环体，然后判断条件是否成立，是否继续执行循环体（先执行后判断）


for循环和while的区别
  * 条件控制语句所控制的自增变量，因为归属for循环的语法结构中，在for循环结束后，就不能再次被访问到了
  * 条件控制语句所控制的自增变量，对于while循环来说不归属其语法结构中，在while循环结束后，该变量还可以继续使用
死循环（无限循环）的三种格式
  1. for(;;){}
  2. while(true){}
  3. do {} while(true);

跳转控制语句的概述



跳转控制语句（break）
  * 跳出循环，结束循环
  * 跳转控制语句（continue）
  * 跳过本次循环，继续下次循环
  * 注意： continue只能在循环中进行使用！



循环嵌套

* 循环嵌套概述：在循环中，继续定义循环

    实例代码:
      public static void main(String[] args) {
          //外循环控制小时的范围，内循环控制分钟的范围
          for (int hour = 0; hour < 24; hour++) {
              for (int minute = 0; minute < 60; minute++) {
                  System.out.println(hour + "时" + minute + "分");
              }
              System.out.println("--------");
          }
      }


* 理解：

  * 请反复理解这句话（整个内循环，就是外循环的一个循环体，内部循环体没有执行完毕，外循环是不会继续向下执行的）

* 结论：

  * 外循环执行一次，内循环执行一圈




Random生成随机数
概述：
  * Random类似Scanner，也是Java提供好的API，内部提供了产生随机数的功能
* API后续课程详细讲解，现在可以简单理解为Java已经写好的代码


使用步骤：

  1. 导入包

     import java.util.Random;

  2. 创建对象

     Random r = new Random();

  3. 产生随机数

     int num = r.nextInt(10);

        代码实例:
获取十个0-100之间的随机数

import java.util.Random;
public class RandomDemo {
    public static void main(String[] args) {
        //创建对象
        Random r = new Random();
        //用循环获取10个随机数
        for(int i=0; i<10; i++) {
            //获取随机数
            int number = r.nextInt(10);
            System.out.println("number:" + number);
        }
        //需求：获取一个1-100之间的随机数
        int x = r.nextInt(100) + 1;
        System.out.println(x);
    }
}
                                                                                                                  

解释： 10代表的是一个范围，如果括号写10，产生的随机数就是0-9，括号写20，参数的随机数则是0-19


练习1.
案例:Random练习-猜数字
随机生成一个1-100的数字,判断用户输入的数字是否和生成的数字相等
import java.util.Random;
import java.util.Scanner;

public class RandomTest {
    public static void main(String[] args) {
        //要完成猜数字的游戏，首先需要有一个要猜的数字，使用随机数生成该数字，范围1到100
        Random r = new Random();
        int number = r.nextInt(100) + 1;
        
        while(true) {
            //使用程序实现猜数字，每次均要输入猜测的数字值，需要使用键盘录入实现
            Scanner sc = new Scanner(System.in);
            
            System.out.println("请输入你要猜的数字：");
            int guessNumber = sc.nextInt();
            
            //比较输入的数字和系统产生的数据，需要使用分支语句。
             //这里使用if..else..if..格式，根据不同情况进行猜测结果显示
            if(guessNumber > number) {
                System.out.println("你猜的数字" + guessNumber + "大了");
            } else if(guessNumber < number) {
                System.out.println("你猜的数字" + guessNumber + "小了");
            } else {
                System.out.println("恭喜你猜中了");
                break;
            }
        }
        
    }
}


上课案例能够独立编写出来（思路清晰完整、代码流畅健壮）
        1. 拿到代码（含思路）之后，先用自己的话补全思路，尽量做到一行代码一个注释。
            目的：把思路捋顺、捋透，用自己最熟悉的语言描述清楚
        2. 删除所有代码，只留下注释，按照注释敲代码（可以多练几遍）
            能够按照注释的思路流畅的写出代码
        3. 所有全部删除，不留任何代码和注释。先写注释，再根据注释写代码（多写几遍，直到熟练为止）
            能够熟练的写出思路和代码

  Java语言跨平台原理（理解）

1.主流的平台有Windows、macOS、Linux，移动平台有IOS、Android
2.Java程序无法跨平台直接运营，是依赖于JVM实现的跨平台。每个平台都有一个自己特有的JVM，正是由于JVM的不跨平台才保障了Java的跨平台。
3.Java提倡的是“一处编译处处运行”。但是大家要注意良好的编码习惯，要不然会变成“一处编译处处调试”，这个随着后面的学习，慢慢会介绍给大家。

JRE和JDK（记忆）
    JVM:    java虚拟机，java编译后的字节码文件运行的平台

    JRE:    java运行环境，包含了Jvm和核心类库

    JDK:    Java开发环境，包含了JRE和开发工具，开发工具包括但不仅限于Javac和java

    JDK:    JRE+开发工具=JVM+核心类库+开发工具
常用DOS命令（应用）

在接触集成开发环境之前，我们需要使用命令行窗口对java程序进行编译和运行，所以需要知道一些常用DOS命令。
    1、打开命令行窗口的方式：win + r打开运行窗口，输入cmd，回车。
    2、常用命令及其作用





注释（理解）
注释是对代码的解释和说明文字，可以提高程序的可读性，因此在程序中添加必要的注释文字十分重要。Java中的注释分为三种：
单行注释。单行注释的格式是使用//，从//开始至本行结尾的文字将作为注释文字。

~~~java
// 这是单行注释文字
~~~

多行注释。多行注释的格式是使用/* 和 */将一段较长的注释括起来。
~~~java
/*
这是多行注释文字
这是多行注释文字
这是多行注释文字
*/
注意：多行注释不能嵌套使用。
~~~
文档注释。文档注释以`/**`开始，以`*/`结束。


关键字（理解）
关键字是指被java语言赋予了特殊含义的单词。

关键字的特点：
​    1.关键字的字母全部小写。
​    2.常用的代码编辑器对关键字都有高亮显示，比如现在我们能看到的public、class、static等。
常量（应用）
    常量：在程序运行过程中，其值不可以发生改变的量。

    Java中的常量分类：

​    字符串常量  用双引号括起来的多个字符（可以包含0个、一个或多个），例如"a"、"abc"、"中国"等

​    整数常量  整数，例如：-10、0、88等

​    小数常量  小数，例如：-5.5、1.0、88.88等

​    字符常量  用单引号括起来的一个字符，例如：'a'、'5'、'B'、'中'等

​    布尔常量  布尔值，表示真假，只有两个值true和false

​    空常量  一个特殊的值，空值，值为null

    除空常量外，其他常量均可使用输出语句直接输出。
数据类型（记忆、应用）

计算机存储单元

我们知道计算机是可以用来存储数据的，但是无论是内存还是硬盘，计算机存储设备的最小信息单元叫“位（bit）”，我们又称之为“比特位”，通常用小写的字母”b”表示。而计算机中最基本的存储单元叫“字节（byte）”，

通常用大写字母”B”表示，字节是由连续的8个位组成。

除了字节外还有一些常用的存储单位，其换算单位如下：

1B（字节） = 8bit

1KB = 1024B

1MB = 1024KB

1GB = 1024MB

1TB = 1024GB

3.4.2 Java中的数据类型

Java是一个强类型语言，Java中的数据必须明确数据类型。在Java中的数据类型包括基本数据类型和引用数据类型两种。


数据类型:分为基本数据类型,引用数据类型两种

一.基本数据类型:  
//八种基本数据类型
1.数值型
    [整数]  byte(字节型),    short ,   int(整型) ,   long(长整型)
    [浮点型]  float,   double,
    [字符型]   char(字符型)
2.非数值型
    (布尔型)boolean   

二引用数据类型(三种):
    类(class)
    接口(interface)
    数组([])
说明：
    e+38表示是乘以10的38次方，同样，e-45表示乘以10的负45次方。
​    在java中整数默认是int类型，浮点数默认是double类型。




变量（应用）
     变量的定义
变量：在程序运行过程中，其值可以发生改变的量。
从本质上讲，变量是内存中的一小块区域，其值可以在一定范围内变化。

变量的定义格式：

数据类型 变量名 = 初始化值; // 声明变量并赋值

还可以在同一行定义多个同一种数据类型的变量，中间使用逗号隔开。但不建议使用这种方式，降低程序的可读性。

变量的使用：
通过变量名访问即可。



3.5.2 使用变量时的注意事项
1. 在同一对花括号中，变量名不能重复。
2. 变量在使用之前，必须初始化（赋值）。
3. 定义long类型的变量时，需要在整数的后面加L（大小写均可，建议大写）。因为整数默认是int类型，整数太大可能超出int范围。
4. 定义float类型的变量时，需要在小数的后面加F（大小写均可，建议大写）。因为浮点数的默认类型是double， double的取值范围是大于float的，类型不兼容。



3.6 标识符（记忆、理解）
标识符是用户编程时使用的名字，用于给类、方法、变量、常量等命名。

Java中标识符的组成规则：

​    1.由字母、数字、下划线“_”、美元符号“$”组成，第一个字符不能是数字。

​    2.不能使用java中的关键字作为标识符。   

​    3.标识符对大小写敏感（区分大小写）。

Java中标识符的命名约定：

​    1.小驼峰式命名：变量名、方法名

​    2.首字母小写，从第二个单词开始每个单词的首字母大写。

​    3.大驼峰式命名：类名

​    4.每个单词的首字母都大写。

​    5.另外，标识符的命名最好可以做到见名知意
        例如：username、studentNumber等。




3.7 类型转换（理解）
在Java中，一些数据类型之间是可以相互转换的。分为两种情况：自动类型转换和强制类型转换。

自动类型转换：
​把一个表示数据范围小的数值或者变量赋值给另一个表示数据范围大的变量。这种转换方式是自动的，直接书写即可

例如:
double num = 10; // 将int类型的10直接赋值给double类型
System.out.println(num); // 输出10.0



强制类型转换：
​把一个表示数据范围大的数值或者变量赋值给另一个表示数据范围小的变量。
范围从大到小:
    byte-short-int-long-float-double
             char-int-long-float-double

​强制类型转换格式：
目标数据类型 变量名 = (目标数据类型)值或者变量;

​    例如：
double num1 = 5.5;
int num2 = (int) num1; // 将double类型的num1强制转换为int类型
System.out.println(num2); // 输出5（小数位直接舍弃）



说明：
1.char类型的数据转换为int类型是按照码表中对应的int值进行计算的。比如在ASCII码表中，'a'对应97。
例如:
int a = 'a';
System.out.println(a); // 将输出97



2. 整数默认是int类型，byte、short和char类型数据参与运算均会自动转换为int类型。
例如:
byte b1 = 10;
byte b2 = 20;
byte b3 = b1 + b2;
// 第三行代码会报错，b1和b2会自动转换为int类型，计算结果为int，int赋值给byte需要强制类型转换。
// 修改为:
int num = b1 + b2;
// 或者：
byte b3 = (byte) (b1 + b2);


3. boolean类型不能与其他基本数据类型相互转换。
运算符&表达式
    运算符其实就是一些符号（eg:+ - * /）
表达式
    用运算符连接起来的一些式子，成为表达式。如果用算术运算符连接起来，就是算术表达式
1. 算术运算符
    + - * / %
    整数相除结果只能是整数
    %取余，结果是余数

    字符相+
    先把自己转换成int值，然后再运算，转换时的原则：按照其在计算机底层的存储值进行转换
    'A'    65
    'a'    97
    '0'    48
    自动类型提升：
    基本数据类型（boolean除外）进行算术运算时，会有自动类型提升：
    a. byte、short、char参与运算时，会自动转换成int类型，然后再进行运算
    b. 在算术表达式中，讲数据类型转换成参与运算的所有数据中的最高级别。
    （byte/short/char<int<long<float<double）

    字符串相+
    其实就是字符串的拼接
    从左往右依次执行，在遇到字符串之前，会找原有的规则进行运算。
    如果遇到了字符串，就开始进行字符串拼接。
   
    自增/自减运算符
    ++/--    变量增加/减少1
    使用：   
        单独使用    在前或在后，对运算结果没有影响
        参与运算
            自增或自减在前，先进行自增减然后再参与其他运算
            自增或自减在后，先进行其他运算，然后再进行自增减   
2.赋值运算符 =
    int i = 10;    //将10赋值给int类型的变量i
    i = i + 20;    //将i的值加上20之后，重新赋值给变量i

    复合赋值运算符
    +=、-=、*=、/=、%=
   
    i += 10;  //在结果上等同于i = (i的类型)(i +10);
    一般不建议使用强转，建议使用复合赋值运算符
3.关系运算符
    关系表达式的结果只能是boolean类型，也就是只能是true或者false
    ==、>、<、>=、<=、!=

    不要将==错写成了=
    System.out.println(i=j+k),把j的值赋值给变量i，并且输出

4. 逻辑运算符
    连接了两个及以上的关系表达式
    &、|、^、!
    & 与    并且    只要有false，结果就是false，同时为true，结果才是true
    | 或    或者    只要有true，结果就是true；同时为false，结果才是false
    ^a异或    男女关系    相同为false，不同为true
    ! 非    否定    !true = false, !false=true; !!true = true;

    短路逻辑运算符
        &&    短路与    只要遇到false，后面的关系表达式便不执行
        ||    短路或    只要遇到true，后面的关系表达式便不执行

    工作中常用的是 &&、||、!
   

5. 三元运算符
    格式：关系表达式 ? 表达式1 : 表达式2


    示例： a > b ? c : d
    执行流程：
        判断关系表达式的值
        如果该值为true，三元表达式的值就是表达式1的值
        如果该值为false，三元表达式的值就是表达式2的值
    求两个数据中，较大的数值
        变量类型 max = a > b ? a : b;




6. 键盘录入的三个步骤
    导包        import java.util.Scanner;
    创建对象    Scanner sc = new Scanner(System.in);
    接收数据    int i = sc.nextInt();


7. if语句格式1
    if(关系表达式){
        语句体   
    }
    执行流程
    1. 判断关系表达式的值
    2. 如果关系表达式的值为true，就执行语句体，然后继续执行后面的其他代码
    3. 如果关系表达式的值为false，就不执行语句体，接续执行后面的其他代码

8. if语句格式2
    if(关系表达式){
        语句体1;
    } else {
        语句体2;
    }

    执行流程：
    1. 判断关系表达式的值
    2. 如果关系表达式的值是true，执行语句体1，然后继续执行后面的其他代码
    3. 如果关系表达式的值是false，执行语句体2，然后继续执行后面的其他代码


9. if语句格式3
    if(关系表达式1){
        语句体1;
    }else if(关系表达式2){
        语句体2;
    }
    ……
    else{
        语句体n+1;
    }

    执行流程
    1. 判断关系表达式1的值，如果是true，就执行语句体1；
    2. 如果为false，就继续判断关系表达式2的值，如果关系表达式2的值是true，就执行语句体2；
    3. ……
    4. 只要有一个关系表达式的值是true，就执行对应的语句体
    5. 如果所有的关系表达式的值都是false，就执行else里面的语句体n+1



范例:判断a/b/c三个数是否相等
使用if语句结构.

    /*
        if语句结构.
    */
   
   
    public class TestScanner{
        public static void main(String []args){
            System.out.println("开始");
            //定义变量
            
            int a=10;
            int b=20;
            int c=10;
            
            //判断a和b是否相等
            if(a == b){
                System.out.println("a=b");
            }
            //判断a和c是否相等
            if(a == c){
                System.out.println("a=c");
            }
            System.out.println("结束");
        }

    }

if else

案例:输入一个数,判断是该数是奇数,还是偶数
使用if else语句结构.
/*
    奇偶数
*/

//导包
import java.util.Scanner;
public class Test{
    public static void main(String [] args){
        //接收数据
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入一个整数");
        int a =sc.nextInt();
        if(a % 2 == 0){
            System.out.println("该数是偶数");
        }else{
            System.out.println("该数是奇数");
        }
        
    }
}


if else if else
案例:从控制台输出1-7,打印对应的星期数
使用if else if else语句结构.
/*
    奇偶数
*/

//导包
import java.util.Scanner;
public class Test{
    public static void main(String [] args){
        //接收数据
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入1-7的星期数");
        int a =sc.nextInt();
        if(a  == 1){
            System.out.println("星期一");
        }else if(a  == 2){
            System.out.println("星期二");
        }else if(a  == 3){
            System.out.println("星期三");
        }else if(a  == 4){
            System.out.println("星期四");
        }else if(a  == 5){
            System.out.println("星期五");
        }else if(a  == 6){
            System.out.println("星期六");
        }else if(a  == 7){
            System.out.println("星期日");
        }else
            System.out.println("输入有误,请重新输入");
        
    }
}

案例:考试奖励案例:
使用if else if else语句结构.
/*
    考试奖励案例
*/

//导包
import java.util.Scanner;
public class Test{
    public static void main(String [] args){
        //接收数据
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入小明的成绩:");
        int a =sc.nextInt();
        if(a  >=95 && a <= 100){
            System.out.println("奖励自行车");
        }else if(a  >=90 && a <= 94){
            System.out.println("旋转木马");
        }else if(a  >=80 && a <= 89){
            System.out.println("变形金刚");
        }else
            System.out.println("挨打");
        
    }
}

循环结构(for,    whlie,    do...while)
(switch语句)

1. switch结构
switch的基本组成格式
     switch(表达式){
        case 值1:
            语句体1;
            break;
        default:
            语句体n+1;
            break;
     }
switch中break的作用
     用于结束整个switch语句的执行
switch中default的执行时机
     当表达式的值，和case给出的值，都没有匹配成功，将会执行default
switch括号中的表达式可以接收的类型
    byte，short，int，char，jdk5开始可以接收枚举，jdk7开始可以接收String
执行流程：
首先计算出表达式的值
其次，和case依次比较，一旦有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结束。
最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉。




练习1:
案例:从控制台输入1-7,输出相应的星期数1-7.
switch语句的使用
/*
    Switch语句
*/

//导包
import java.util.Scanner;
public class Test{
    public static void main(String [] args){
        System.out.println("开始");
        //接收数据
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入一个星期数(1-7):");
        int a =sc.nextInt();
        switch(a){
            case 1:
            System.out.println("星期一");
            break;
        
            case 2:
            System.out.println("星期二");
            break;
        
            case 3:
            System.out.println("星期三");
            break;
        
            case 4:
            System.out.println("星期四");
            break;
        
            case 5:
            System.out.println("星期五");
            break;
        
            case 6:
            System.out.println("星期六");
            break;
        
            case 7:
            System.out.println("星期日");
            break;
        
            default:
            System.out.println("输入有误,请重新输入");
        
        }
    }
}

练习2:
案例:春夏秋冬
switch语句case穿透的使用
/*
    Switch语句
    一年12个月,春夏秋冬
*/

//导包
import java.util.Scanner;
public class Test{
    public static void main(String [] args){
        System.out.println("开始");
        //接收数据
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入一个月份(1-12)");
        int a =sc.nextInt();
        switch(a){
        //case穿透
            case 1:
            case 2:
            case 12:
                System.out.println("冬季");
            break;
            case 3:
            case 4:
            case 5:
                System.out.println("春季");
                break;
            case 6:
            case 7:
            case 8:
                System.out.println("夏季");
            case 9:
            case 10:
            case 11:
                System.out.println("秋季");
                break;
            default:
            System.out.println("输入有误,请重新输入");
        
        }
    }
}


循环语句()
for循环语句
循环语句可以在满足循环条件的情况下，反复执行某一段代码，这段被重复执行的代码被称为循环体语句，当反复 执行这个循环体时，需要在合适的时候把循环判断条件修改为false，从而结束循环，否则循环将一直执行下去，形成死循环。
格式解释：

  * 初始化语句：  用于表示循环开启时的起始状态，简单说就是循环开始的时候什么样
  * 条件判断语句：用于表示循环反复执行的条件，简单说就是判断循环是否能一直执行下去
  * 循环体语句：  用于表示循环反复执行的内容，简单说就是循环反复执行的事情
  * 条件控制语句：用于表示循环执行中每次变化的内容，简单说就是控制循环是否能执行下去




执行流程：

  ①执行初始化语句
  ②执行条件判断语句，看其结果是true还是false
  ​             如果是false，循环结束
  ​             如果是true，继续执行
  ③执行循环体语句
  ④执行条件控制语句
  ⑤回到②继续




练习1.
案例:从1输出到5
for循环语句的使用
public class ForDemo{
    public static void main(String[] args){
        //for循环
        for(int i=1;i<=5;i++){
            System.out.println(i);
        }
    }
   
}


练习2.
案例:从1输出到5,从5输出到1
for循环语句的使用
public class ForDemo{
    public static void main(String[] args){
        //for循环
        for(int i=1;i<=5;i++){
            System.out.println(i);
        }
            System.out.println("-----------------");
        for(int j=5;j >=1;j--){
            System.out.println(j);
        
        }
    }
   
}

练习3:
案例:1-5之间的和
重点:理解            +=用法
public class ForTest{
        //for循环求1-5的和
    public static void main(String[] args){
        //定义变量
        int sum=0;
        //for循环语句
        for(int i=1;i<=5;i++){
            sum +=i;
                       /*
                           sum += i; sum=sum+i;
                               第一次:sum=sum+i; sum= 0 + 1 = 1;
                               第二次:sum=sum+i; sum = 1 + 2 = 3;
                               第三次:sum=sum+i; sum = 3 + 3 = 6;
                               第四次:sum=sum+i; sum = 6 + 4 = 10;
                               第五次:sum=sum+i; sum = 10 + 5 = 15;
                       */
        }
        System.out.println("1-5的和是:" +sum);
            
    }
   
}

42.求偶数和
public class ForTest{
        //for循环求1-100之间的偶数和
    public static void main(String[] args){
        //定义变量
        int sum=0;
        //for循环语句
        for(int i=1;i<=100;i++){
            if(i % 2 == 0){
                sum +=i;
            }        
    }
        System.out.println("1-100的偶数和是:" +sum);
    }
}

  练习4.
         案例:在控制台输出所有的水仙花数
for循环的运用
说明:几位数字就除以单位在进行取余(%10)即可
水仙花数:是一个三位数,数字的各个位数的立方和.列如:371=3^3+7^3+1^3=371
public class ForTest{
         //水仙花案例   
        //for循环输出所有的水仙花数
    public static void main(String[] args){
        //定义变量
        //for循环语句从100开始-999结束
        for(int i=100;i<=999;i++){
            //在计算之前获取三位数中每个位子上的值
            int ge=i%10;
            int shi=i/10%10;
            int bai=i/100%10;
            //判断条件是将三位数中的每个数值取出来,计算立方和后与原始数据是否相等
            if(ge*ge*ge+shi*shi*shi+bai*bai*bai ==i){
                System.out.println(i);
            }        

    }
    }
}


练习5.
for循环的运用
案例:统计水仙花的个数:
public class TestSix{
        //统计案例
        //计算一共有几个水仙花数
    public static void main(String[]args){
        //定义变量,存储水仙花数的个数
            int count=0;
            //for循环输出所有的水仙花数
            for(int i=100;i<=999;i++){
                //计算每个位置上的值
                int ge=i%10;
                int shi=i/10%10;
                int bai=i/100%10;
               
                //判断条件是将三位数中的每个数值取出来,计算立方和后是否与原数相等
                if(ge*ge*ge+shi*shi*shi+bai*bai*bai == i){
                    count++;
                }
               
            }
            System.out.println(count);
    }
}



while循环语句
     while循环完整格式：

  初始化语句;
  while (条件判断语句) {
      循环体语句;
      条件控制语句;
  }


* while循环执行流程：

  ①执行初始化语句

  ②执行条件判断语句，看其结果是true还是false
  ​             如果是false，循环结束
  ​             如果是true，继续执行
  ③执行循环体语句

  ④执行条件控制语句
  ⑤回到②继续


练习1.
案例:输出五次HelloWorld
while语句的运用
public class TestSix{
        //While语句
        //输出5次HelloWord
    public static void main(String[]args){
        //while循环
        int i=1;
        while(i<=5){
            System.out.println("HelloWorld");
            i++;
        }
    }
}


练习2.
案例:珠穆朗玛峰
珠穆朗玛峰(8844.43米=8844430毫米),一张白纸厚度是0.1毫米要折叠多少次,可以叠到珠穆朗玛峰的高度
while语句的运用
public class TestSix{
        //While案例:珠穆朗玛峰
        //珠穆朗玛co峰(8844.43米=8844430毫米),一张白纸厚度是0.1毫米要折叠多少次,可以叠到珠穆朗玛峰的高度
    public static void main(String[]args){
        //定义变量,存储折叠次数
        int count=0;//折叠次数
        //while循环
        double paper=0.1;//纸张厚度
        int zf=8844430;//珠峰高度
        while(paper<=zf){
                //循环的执行过程中纸张的厚度要加倍.
                paper*=2;
                //在循环中执行累加,对应折叠了多少次
                count++;
            }
            System.out.println("需要折叠"+count+"次");
    }
}


do...while循环语句
完整格式：
  初始化语句;
  do {
      循环体语句;
      条件控制语句;
  }while(条件判断语句);

执行流程：

  ① 执行初始化语句

  ② 执行循环体语句

  ③ 执行条件控制语句

  ④ 执行条件判断语句，看其结果是true还是false

  如果是false，循环结束

  如果是true，继续执行

  ⑤ 回到②继续



练习1.
案例:利用do while输出5次"HelloWorld"
do while语句的运用
public class DoWhile{
    public static void main(String[]args){
        int i=1;
        do{
            System.out.println("Helloworld");
            i++;
        }while(i<=5);
    }
}



三种循环的区别            
三种循环的区别
  * for循环和while循环先判断条件是否成立，然后决定是否执行循环体（先判断后执行）
  * do...while循环先执行一次循环体，然后判断条件是否成立，是否继续执行循环体（先执行后判断）


for循环和while的区别
  * 条件控制语句所控制的自增变量，因为归属for循环的语法结构中，在for循环结束后，就不能再次被访问到了
  * 条件控制语句所控制的自增变量，对于while循环来说不归属其语法结构中，在while循环结束后，该变量还可以继续使用
死循环（无限循环）的三种格式
  1. for(;;){}
  2. while(true){}
  3. do {} while(true);

跳转控制语句的概述



跳转控制语句（break）
  * 跳出循环，结束循环
  * 跳转控制语句（continue）
  * 跳过本次循环，继续下次循环
  * 注意： continue只能在循环中进行使用！



循环嵌套

* 循环嵌套概述：在循环中，继续定义循环

    实例代码:
      public static void main(String[] args) {
          //外循环控制小时的范围，内循环控制分钟的范围
          for (int hour = 0; hour < 24; hour++) {
              for (int minute = 0; minute < 60; minute++) {
                  System.out.println(hour + "时" + minute + "分");
              }
              System.out.println("--------");
          }
      }


* 理解：

  * 请反复理解这句话（整个内循环，就是外循环的一个循环体，内部循环体没有执行完毕，外循环是不会继续向下执行的）

* 结论：

  * 外循环执行一次，内循环执行一圈




Random生成随机数
概述：
  * Random类似Scanner，也是Java提供好的API，内部提供了产生随机数的功能
* API后续课程详细讲解，现在可以简单理解为Java已经写好的代码


使用步骤：

  1. 导入包

     import java.util.Random;

  2. 创建对象

     Random r = new Random();

  3. 产生随机数

     int num = r.nextInt(10);

        代码实例:
获取十个0-100之间的随机数

import java.util.Random;
public class RandomDemo {
    public static void main(String[] args) {
        //创建对象
        Random r = new Random();
        //用循环获取10个随机数
        for(int i=0; i<10; i++) {
            //获取随机数
            int number = r.nextInt(10);
            System.out.println("number:" + number);
        }
        //需求：获取一个1-100之间的随机数
        int x = r.nextInt(100) + 1;
        System.out.println(x);
    }
}
                                                                                                                  

解释： 10代表的是一个范围，如果括号写10，产生的随机数就是0-9，括号写20，参数的随机数则是0-19


练习1.
案例:Random练习-猜数字
随机生成一个1-100的数字,判断用户输入的数字是否和生成的数字相等
import java.util.Random;
import java.util.Scanner;

public class RandomTest {
    public static void main(String[] args) {
        //要完成猜数字的游戏，首先需要有一个要猜的数字，使用随机数生成该数字，范围1到100
        Random r = new Random();
        int number = r.nextInt(100) + 1;
        
        while(true) {
            //使用程序实现猜数字，每次均要输入猜测的数字值，需要使用键盘录入实现
            Scanner sc = new Scanner(System.in);
            
            System.out.println("请输入你要猜的数字：");
            int guessNumber = sc.nextInt();
            
            //比较输入的数字和系统产生的数据，需要使用分支语句。
             //这里使用if..else..if..格式，根据不同情况进行猜测结果显示
            if(guessNumber > number) {
                System.out.println("你猜的数字" + guessNumber + "大了");
            } else if(guessNumber < number) {
                System.out.println("你猜的数字" + guessNumber + "小了");
            } else {
                System.out.println("恭喜你猜中了");
                break;
            }
        }
        
    }
}


上课案例能够独立编写出来（思路清晰完整、代码流畅健壮）
        1. 拿到代码（含思路）之后，先用自己的话补全思路，尽量做到一行代码一个注释。
            目的：把思路捋顺、捋透，用自己最熟悉的语言描述清楚
        2. 删除所有代码，只留下注释，按照注释敲代码（可以多练几遍）
            能够按照注释的思路流畅的写出代码
        3. 所有全部删除，不留任何代码和注释。先写注释，再根据注释写代码（多写几遍，直到熟练为止）
            能够熟练的写出思路和代码