Java-基础篇【Java安装运行基础、类型转换、常用运算符、流程控制】

1：Java背景知识

Java是美国 sun 公司（Stanford University Network）在1995年推出的一门计算机高级编程语言。
Java 早期称为Oak(橡树)，后期改名为Java。
Java 之父：詹姆斯·高斯林(James Gosling)。
2009年 sun公司被Oracle公司收购

2：Java技术体系

3：Java安装

验证JDK安装成功的方式：查询JDK的版本号
　　在命令行 窗口中分别输入javac –version 及 java –version看版本提示，如果版本提示与自己安装的版本号一致，则代表JDK环境搭建成功

4：Javac 和 java介绍

5：Java 程序开发的三个步骤

6：入门程序Hello world　　

package com.ywt.hello.hello;
import java.sql.SQLOutput;
public class HelloWorld {
    public static void main(String[] args) {    // main补全
        System.out.println("hello World");   // sout 补全
    }
}
/*
IDEA的结构都是什么样的：
    project - module - package – class
注意：文件名称必须与代码中的类名称一致。
保存文件：ctrl + s
*/

7：编译代码，运行代码

8：JDK的组成

9：配置Java_home 环境变量

10：IDEA项目结构

11：IDEA 工具快捷操作　　ctrl +

12：注释

什么是注释
    注释是写在程序中对代码进行解释说明的文字，方便自己和其他人查看，以便理解程序的。

注释有哪些
    单行注释：// 注释内容，只能写一行
    多行注释：/*     */
    文档注释：/**     */     文档注释的内容是可以提取到一个程序说明文档中去的

快捷键进行注释：
    单行注释（对当前行进行注释）：　　Ctrl + / 
    对选中的代码进行多行注释：　　Ctrl + Shift + /

13：字面量

字面量：
    计算机是用来处理数据的，字面量就是告诉程序员：数据在程序中的书写格式。

常用数据

字符、字符串在程序中的书写格式有什么要求？
    字符　　必须单引号围起来，有且仅能一个字符。
    字符串　　必须用双引号围起来。
几个常见的特殊值的书写格式是？
    true、false、null、\n、\t

package com.ywt.hello.literal;

public class LiteralDemo {
    public static void main(String[] args) {
        // 目标：学会常见字面量数据在程序中的书写格式。
        // 1、整数、小数
        System.out.println(666);
        System.out.println(3.14);

        // 2、字符：加单引号，有且仅能有一个字符
        System.out.println('a');
        System.out.println('A');
        System.out.println('0');
        System.out.println('中');
        //System.out.println('中国'); // 报错的
        //System.out.println(''); // 报错的
        System.out.println(' ');
        // 注意：几个特殊字符
        System.out.println('a');
        System.out.println('\n'); // \n代表换行
        System.out.println('a');
        System.out.println('\t'); // \t代表一个tab

        // 3、字符串：加双引号，里面的内容可以随便写
        System.out.println("");
        System.out.println("    ");
        System.out.println("程序员");
        System.out.println("我爱您中国 abc 1234324 ");

        // 4、布尔值：true , false
        System.out.println(true);
        System.out.println(false);
    }
}

14：变量

什么是变量：
    变量就是内存中的一块区域，用来存储一个数据的，且存储的数据可以被替换

定义变量需要注意的几个问题：
　　变量要先声明再使用
　　变量声明后，不能存储其他类型的数据。
　　变量的有效范围是从定义开始到“}”截止,且在同一个范围内部不能定义2个同名的变量
　　变量定义的时候可以没有初始值，但是使用的时候必须给初始值

package com.ywt.hello.variable;

/**
 目标：学会定义并使用变量。
 */
public class VariableDemo1 {
    public static void main(String[] args) {
        // 数据类型 变量名称 = 初始值;
        // 注意：从右往左边看的（赋值）
        int age = 21;
        System.out.println(age);

        age = 25;
        System.out.println(age);

        System.out.println("-------------实际操作------------");
        double money = 6.0;
        System.out.println(money);

        // 收红包4元
        money = money + 4.0;
        System.out.println(money);
    }
}
// 变量就是内存中的一块区域，用来存储一个数据的，且存储的数据可以被替换。

package com.ywt.hello.variable;
/**
 * 目标：理解变量定义的注意事项，并注意
 * */
public class VariableDemo2 {
    public static void main(String[] args) {
//        1、变量要先声明再使用
          int age = 21;
          age = 25;
          System.out.println(age);

//        2、变量声明后，不能存储其他类型的数据。
          // age = 35.9;

//        3、变量的有效范围是从定义开始到“}”截止,且在同一个范围内部不能定义2个同名的变量。
         {
             double money = 23.5;
             System.out.println(money);
             // double money = 10.4; // 报错
             // int age = 28; // 报错
         }
//         System.out.println(money); // 报错
        System.out.println(age);
        double money = 99.5;
        System.out.println(money);

//        4、变量定义的时候可以没有初始值，但是使用的时候必须给初始值。
        int number ;
        number = 100;
        System.out.println(number);

        System.out.println("----------------数据在底层存储的原理：二进制形式------------------");
        char ch = 'a'; // ch = 97
        System.out.println(ch + 1);
        System.out.println(ch); // a

        int i1 = 0b01100001;    // 二进制
        System.out.println(i1);     // 输出 97

        int i2 = 0141;      // 八进制
        System.out.println(i2);    // 输出 97

        int i3 = 0x61;          // 十六进制
        System.out.println(i3); // 输出 97
    }
}

package com.ywt.hello.variable;

/**
   引用数据类型：string
   基本数据类型：4 种 8大类
        整数
        浮点数
        字符
        布尔
 关键字：
    public ....
 */
public class VariableDemo3 {
    public static void main(String[] args) {
        // 目标：掌握常用8种基本数据类型定义变量。
        // 1、byte 字节型       1个字节
        byte age = 120;
        byte age2 = 127;
        // byte age3 = 128;     // 报错

        // 2、short 短整型      2个字节
        short s1 = 32542;
        // short s2 = 42542;        // 报错

        // 3、int 整型 (默认类型，如果不确定数据的范围会多大，就用int)      4个字节
        int i = 1;
        int it = 243244244;

        // 4、long 长整型                   8个字节
        long l = 32332323;
        // 注意：随便写一个字面量34243243243245默认是当成int类型的，34243243243245虽然没有超过long的范围
        // 但是34243243243245它超过了int本身的范围，如果希望34243243243245这个数据是long类型的，需要在后面加L l
        long l2 = 34243243243245L;

        // 5、浮点型（小数）                4个字节
        // float称为单精度小数：注意：随便写一个小数字面量默认是double类型的，如果希望随便写一个小数默认是float类型的需要加上F/f
        float f = 3.14F;

        // 6、double 双精度             8个字节
        double score = 99.5;

        // 7、字符型                2个字节        0-65535字符       只能放一个值
        char ch = '徐';
        char ch1 = '黑';

        // 8、布尔类型               1个字节
        boolean flag = true;
        boolean flag2 = false;

        System.out.println("--引用数据类型：String--");
        // String表示的是字符串类型，定义的变量可以存储一个字符串
        String name = "西门吹雪";
        System.out.println(name);

        int class1 = 21;
        int itheima = 23;
    }
}

15：Java中二进制，八进制，十六进制简介

二进制：
    除 2 取 余，从下往上取

计算机 8 位 一组一个字节存储数据
1位 1bit    1byte【字节】 = 8 bit     简写 1B=8b

char ch = "a";
ASCII 编码
    a = 97      97转成二进制

图片：
    像素点，颜色数据
    像素点对应的二进制形式

声音：
    声波，二进制表示波形

2 进制转 10 进制
   n*2*0 + n*2*1 + n*2*2 .......

8进制
    2 进制3位当成一组来看

16级制
    2 进制4位当成一组来看

java中
    0B/0b：二进制
    0：八进制
    0X/0x :十六进制

计算机中的数据的最小单位：
　　计算机中数据最小的组成单元：使用8个二进制位为一组，称之为一个字节（byte,简称B）
　　字节中的每个二进制位就称为 位（bit，简称b）,  1B = 8b

16：关键字

17：标识符

18：基本数据类型之——整型

随便写的整数、小数字面值默认什么类型？
　　23 　　　　默认是int类型 , 加上L/l就是long类型的数据了。
　　23.8　　　　默认是double类型，加上F/f就是float类型了。

19：自动类型转换

package com.itheima.type;
/**
 * 目标：理解自动类型转换
 * */
public class TypeDemo1 {
    public static void main(String[] args) {
        byte a = 20;
        int b = a; // 发生了自动类型转换
        System.out.println(a);      // 20
        System.out.println(b);      // 20

        int age = 23;
        double db = age; // 自动类型转换
        System.out.println(db);         // 23.0

        char ch = 'a'; // 00000000 01100001
        int code = ch; // 00000000 00000000 00000000 01100001       字符可以转 int
        System.out.println(code);       // 97
    }
}
/*
字段类型转换：
    类型范围 小的变量 赋值给类型范围大的变量

字段类型转换：
    byte   ——>   short   ——>   int  ——>   long  ——>   float ——>    double
    byte 、short、char   ——>   int  ——>   long   ——>  float ——>    double
    byte 、short、char 程序里直接转换成int 运算的
 */

20：表达式的自动类型转换

package com.itheima.type;
/**
 * 目标：掌握表达式的自动类型转换的规则。
 * */
public class TypeDemo2 {
    public static void main(String[] args) {
        byte a = 10;
        int b = 20;
        double c = 1.0;
        double rs = a + b + c;      // 31.0   double接收才不报错，double是最高的
        System.out.println(rs);

        double rs2 = a + b - 2.3;       // 27.7  2.3是 double
        System.out.println(rs2);

        // 面试题
        byte i = 100;
        byte j = 120;
        int k = i + j;
        System.out.println(k);
    }
}

21：强制类型转换：强行将范围大的变量，数据赋值给范围小的变量

package com.itheima.type;
/**
 * 目标：理解强制类型转换，并使用。
 * */
public class TypeDemo3 {
    public static void main(String[] args) {
        int a = 20;
        byte b = (byte)a;
        System.out.println(a);      //20
        System.out.println(b);      // 20

        int i = 1500;
        byte j = (byte) i;
        System.out.println(j);      // -36

        double score = 99.5;
        int it = (int) score;
        System.out.println(it); // 99
    }
}
/*
自动类型转换只能小到大：
    byte   ——>   short   ——>   int  ——>   long  ——>   float ——>    double
强制类型转换
    使用函数强制 把大范围变量可以转换成小范围变量的
        int a = 20;
        byte b = (byte)a;
    int：4字节
    byte：1字节
    int转byte，直接只拿后1个字节，前面3字节丢弃

强制类型转换可能造成数据(丢失)溢出；
浮点型强转成整型，直接丢掉小数部分，保留整数部分返回
 */

22：基本算术运算符　　+ - * /　　%

Tips：如果两个整数做除法，其结果一定是整数，因为最高类型是整数

package com.itheima.operator;
/**
 * 目标：掌握基本的算术算术运算符的使用：+ - * / %
 * */
public class OperatorDemo1 {
    public static void main(String[] args) {
        int a = 10;
        int b = 3;
        System.out.println(a + b);
        System.out.println(a - b);
        System.out.println(a * b);
        System.out.println(a / b); // 3.3333  ==>  3        运算 a整数，b整数，最大的数值范围就是整数
        System.out.println(a * 1.0 / b); // 3.3333          一定要得到一个小数  a * 1.0 【 *1.0一点放前面，放后面不行，完了，已经算出3了 】
        System.out.println(3 / 2);
        System.out.println(3 * 1.0 / 2); // 1.5
        System.out.println(3  / 2 * 1.0); // 1.0
        System.out.println(a % b); // 1
    }
}

package com.itheima.operator;
/**
 * 目标：拆分三位数【百位，十位，个位】
 * */
public class OperatorTest2 {
    public static void main(String[] args) {
        // 需求：拆分3位数，把个位、十位、百位分别输出
        int data = 589;

        // 1、个位
        int ge = data % 10;
        System.out.println(ge);

        // 2、十位
        int shi = data / 10 % 10;       //  data / 10 得到 58再求余数
        System.out.println(shi);

        // 3、百位
        int bai = data / 100;           // 保留整数值
        System.out.println(bai);
    }
}

23： + 当作连接符

package com.itheima.operator;
/**
 * 目标：+符号做连接符的识别：能算则算，不能算连接在一起
 * */
public class OperatorDemo3 {
    public static void main(String[] args) {
        int a = 5 ;
        System.out.println("abc" + 'a'); // abca
        System.out.println("abc" + a);   // abc5
        System.out.println(5 + a); // 10
        System.out.println("abc" + 5 + 'a'); // abc5a
        System.out.println(15 + "abc" + 15); // 15abc15
        System.out.println(a + 'a'); // 102     变量 a 和字符 "a"能运算的
        System.out.println(a + "" +'a'); // 5a
        System.out.println(a + 'a'+" itheima "); // 102 itheima
        System.out.println("itheima"+ a + 'a'); // itheima5a
        System.out.println("itheima"+ ( a + 'a' ));// itheima102
        System.out.println("a" + "a");
    }
}

24：自增自减运算符 ++ 　　--

package com.itheima.operator;
/**
 * 目标：学会使用自增自减运算符： ++ --
 * */
public class OperatorDemo4 {
    public static void main(String[] args) {
        int a = 10;
        // a++; // a = a + 1
        ++a; // a = a + 1
        System.out.println(a);          // 11

        int b = 10;
        //b--; // b = b -1
        --b;
        System.out.println(b);      // 9

        System.out.println("------------------------------");
        // 在表达式中或者不是单独操作的情况，++ -- 在变量前后存在区别
        // ++ -- 在变量前面。先+1 -1 再使用。
        int i = 10;
        int j = ++i;
        System.out.println(i); // 11
        System.out.println(j); // 11

        // ++ -- 在变量的后面 先使用再+1 -1
        int m = 10;
        int n = m++;
        System.out.println(m); // 11
        System.out.println(n); // 10

        System.out.println("-----------拓展案例（可以了解和参考）--------------");
        int k = 3;
        int p = 5;
        // k  3 4 5 4
        // p  5 4 3 4
        // rs    3  +  5  -   4  + 4   - 5   +  4 + 2
        int rs = k++ + ++k - --p + p-- - k-- + ++p + 2;
        System.out.println(k); // 4
        System.out.println(p); // 4
        System.out.println(rs); // 9
    }
}
/*
++ 和 -- 单独使用放前面和后面没有差别

++ 和 -- 用在表达式中有区别：
    在变量前 ，先进行变量自增/自减，再使用变量
    在变量后 ，先使用变量，再进行变量自增/自减

k++：先用   K=3 用完之后K马上变成4【先用所以rs第一位为 3 】
++k：先加   k从4变成了K=5，先加所以【后用所以rs第二位为  5】
--p：先减   p从5变成p=4【后用所以rs第三位为4】
p--：先用   p从4变成了p=3【先用所以rs第四位为4】
k--：先用   K从5变成了K=4【先用所以rs第五位为5】
++p：先加   p从3变成了P=4【后用所以rs第六位为4】
rs： 3【现用】+ 5【先加】 - 4 + 4 - 5 + 4 + 2
K=4 P=4  rs=9
 */

25：赋值运算符 = += -=

package com.itheima.operator;
/**
 * 目标：学会使用赋值运算符：= += -= *= /= %=
 * */
public class OperatorDemo5 {
    public static void main(String[] args) {
        int a = 10;
        int b = 200;
        // a = a + b;
        a += b; // a = (int)(a + b)
        System.out.println(a);

        byte i = 10;
        byte j = 20;
        // i = (byte) (i + j);
        i += j; // i = (byte) (i + j);
        System.out.println(i);

        int m = 10;
        int n = 5;
        //m += n;
        //m -= n;  // 等价于： m = (int)(m - n)
        //m *= n;  // 等价于： m = (int)(m * n)
//        m /= n;  // 等价于： m = (int)(m / n)
        m %= n;  // 等价于： m = (int)(m % n)
        System.out.println(m);
    }
}

26：关系运算符：== ！= > <

package com.itheima.operator;
/**
 * 目标：学会使用关系运算符。
 * */
public class OperatorDemo6 {
    public static void main(String[] args) {
        int a = 10;
        int b = 10;

        boolean rs = a == b;        // 判断是否相等
        System.out.println(rs);

        System.out.println(a == b);
        System.out.println(a != b); // false  不等于
        System.out.println(a > b); //  false
        System.out.println(a >= b); // true
        System.out.println(a < b); // false
        System.out.println(a <= b); // true

        int i = 10;
        int j = 5;
        System.out.println(i == j); // false
        System.out.println(i != j); // true
        System.out.println(i > j); // true
        System.out.println(i >= j); // true
        System.out.println(i < j); // false
        System.out.println(i <= j); // false

        System.out.println(i = j); // 5 相等判断必须是== 如果使用=是在进行赋值操作！
    }
}

27：逻辑运算符 && || ! ^

package com.itheima.operator;
/**
 * 目标：学会使用逻辑运算符，并能够选择合适的逻辑运算符解决问题。
 * */
public class OperatorDemo7 {
    public static void main(String[] args) {
        double size = 9.8;
        double storage = 6;
        // 需求：尺寸大于等于6.95 内存要大于等于8GB
        System.out.println(size >= 6.95 & storage >=8);     // 注意：必须前后都是true结果才是true

        // 需求：要么内存大于等于8 要么尺寸大于等于6.95
        System.out.println(size >= 6.95 | storage >=8);      // 注意：只要有一个是true 结果就一定是true    |

        System.out.println(!true);
        System.out.println(!false);

        // 逻辑异或：必须两个不同结果才是true
        System.out.println(false ^ true); // true
        System.out.println(true ^ false); // true
        System.out.println(true ^ true); // false
        System.out.println(false ^ false); // false

        System.out.println("-----------&&  &  || |的区别-------------------");
        int a = 10;
        int b = 20;
         System.out.println(a > 100 && ++b > 10);       // ++b 不会执行  b还是20
//        System.out.println(a > 100 & ++b > 10);     // ++b 会执行  b还是21
        System.out.println(b);

        int i = 10;
        int j = 20;
        //System.out.println(i > 2 || ++j > 10);
        System.out.println(i > 2 | ++j > 10);
        System.out.println(j);
    }
}
/*
&   逻辑与     必须都是true，结果才是true; 只要有一个是false，结果一定是false
|   逻辑或     只要有一个为true、结果就是true
！  逻辑非      你真我假、你假我真。 !true=false 、 !false= true
^   逻辑异或    如果两个条件都是false或者都是true则结果是false。两个条件不同结果是true

&&  短路与     判断结果与“&”一样。过程是左边为 false，右边则不执行,左边false就能确定结果，性能好
||  短路或     判断结果与“|”一样。过程是左边为 true， 右边则不执行，左边true就能确定结果，性能好
| 和 & 前后不管怎么都会执行
*/

28：三元运算符

package com.itheima.operator;
/**
 * 目标：学会使用三元运算符，理解其流程
 * */
public class OperatorDemo8 {
    public static void main(String[] args) {
        double score = 18;
        String rs = score >= 60 ? "考试通过" : "挂科";
        System.out.println(rs);

        // 需求：需要从2个整数中找出较大值
        int a = 10000;
        int b = 2000;
        int max = a > b ? a : b;
        System.out.println(max);

        System.out.println("-------求三个整数的最大值-----------");
        int i = 10;
        int j = 30;
        int k = 50;
        // 1、找出2个整数的较大值
        int temp = i > j ? i : j;       // 2、拿临时变量与第三个变量的值继续比较
        int rsMax = temp > k ? temp : k;
        System.out.println(rsMax);

        System.out.println("-------------求三个整数的最大值：拓展知识-------------");
        int rsMax1 = i > j ? (i > k ? i : k) : (j > k ? j : k); // 不加括号也行
        // 问 i 有没有 大于 j
        // i > j i比较大，拿i和k比，走 (i > k ? i : k)
        // 反之
        System.out.println(rsMax1);
    }
}
/*
格式：条件表达式 ?  值1 : 值2;
    首先计算关系表达式的值，如果值为true，返回值1，如果为false，返回值2
*/

29：运算符优先级

package com.itheima.operator;
/**
 * 目标：看看Java是否存在优先级，大家以后需要注意优先级问题
 * */
public class OperatorDemo9 {
    public static void main(String[] args) {
        // 目标：看看Java是否存在优先级，大家以后需要注意优先级问题
        System.out.println(10 > 3 || 10 > 3 && 10 < 3);  //true
        System.out.println( (10 > 3 || 10 > 3 ) && 10 < 3); // false
    }
}
/*
()
! -：取反 ++：自增 --：自减
....
 */

30：导包操作

package com.itheima.scanner;
import java.util.Scanner;
/**
 * 1、导包操作 (并不需要自己写的，以后通过工具进行导入更方便)
 * */
public class ScannerDemo {
    public static void main(String[] args) {
        // 目标：接收用户的键盘输入的数据。
        Scanner sc = new Scanner(System.in);         // 2、得到一个键盘扫描器对象

        System.out.println("请您输入您的年龄：");
        int age = sc.nextInt();             // 3、等待接收用户输入一个整数，按了回车键才会把数据交给age变量
        System.out.println("您的年龄是：" + age);

        System.out.println("请您输入您的名称：");
        String name = sc.next();            // 4、等待接收用户输入一个字符串，按了回车键才会把数据交给name变量
        System.out.println(name + "欢迎进入系统！");
    }
}
/*
System.out.println  不需要导包，默认的lang 包主动导入
 */

31：if分支结构

if 第一种格式：
    首先判断条件表达式的结果，如果为true执行语句体，为 false 就不执行语句体

注意事项：
    if 语句中，如果大括号控制的只有一行代码，则大括号可以省略不写

if 第二种格式：
    首先判断条件表达式的结果，如果为true执行语句体1，为 false 就执行语句体2。

if 第三种格式：
    先判断条件1的值，如果为true则执行语句体1，分支结束；如果为false            则判断条件2的值
    如果值为true就执行语句体2，分支结束；如果为false则判断条件3的值
    ...
    如果没有任何条件为true，就执行else分支的语句体n+1。

package com.itheima.branch;

/**
     目标：学会使用if分支结构解决问题，理解其流程。
 */
public class IfDemo1 {
    public static void main(String[] args) {
        // 需求：心跳（60 - 100）之间是正常的，否则系统提示进一步检查
        // 格式1： if(条件表达式){  代码... }
        int heartBeat = 30;
        if(heartBeat < 60 || heartBeat > 100) {
            System.out.println("您的心跳数据是：" + heartBeat +"，您可能需要进一步检查！");
        }
        System.out.println("检查结束");

        // 格式2： if(条件表达式){ 代码... } else {  代码... }
        // 需求：发红包。
        double money = 1;
        // 发送一个1314.
        if(money >= 1314){
            System.out.println("您当前发送红包成功~~~");
        }else {
            System.out.println("您自己都没钱，就别发了~~");
        }

        // 格式3： if(条件表达式){ 代码...}else if(条件表达式){ 代码... } ... else{ 代码...}
        // 绩效系统： 0-60 C  60-80 B 80-90 A 90-100 A+
        int score = 199;
        if(score >= 0 && score < 60){
            System.out.println("您本月的绩效是：C");
        }else if(score >= 60 && score < 80){
            System.out.println("您本月的绩效是：B");
        }else if(score >= 80 && score < 90){
            System.out.println("您本月的绩效是：A");
        }else if(score >= 90 && score <= 100){
            System.out.println("您本月的绩效是：A+");
        }else {
            System.out.println("您录入的分数有毛病！");
        }
    }
}

32：switch分支

switch分支的格式、执行流程是怎么样的？
if、switch分支各自适合做什么业务场景？
　　if其实在功能上远远强大于switch。
　　if适合做区间匹配。
　　switch适合做：值匹配的分支选择、代码优雅

switch分支注意事项：
    表达式类型只能是 byte、short、int、char， JDK5开始支持枚举，JDK7开始支持String、不支持double、float、long。
　　case给出的值不允许重复，且只能是字面量，不能是变量。
　　不要忘记写break，否则会出现穿透现象

package com.itheima.branch;
/**
 * 目标：学会使用switch分支结构，理解流程
 * */
public class SwitchDemo2 {
    public static void main(String[] args) {
        // 周一：埋头苦干，解决bug                                  周五：今晚吃鸡
        // 周二：请求大牛程序员帮忙                             周六：与王婆介绍的小芳相亲
        // 周三：今晚啤酒、龙虾、小烧烤                              周日：郁郁寡欢、准备上班。
        // 周四： 主动帮助新来的女程序解决bug
        String weekday = "周二";
        switch (weekday){
            case "周一":
                System.out.println("埋头苦干，解决bug ");
                break;
            case "周二":
                System.out.println("请求大牛程序员帮忙");
                break;
            case "周三":
                System.out.println("今晚啤酒、龙虾、小烧烤");
                break;
            case "周四":
                System.out.println("主动帮助新来的女程序解决bug");
                break;
            case "周五":
                System.out.println("今晚吃鸡");
                break;
            case "周六":
                System.out.println("与王婆介绍的小芳相亲");
                break;
            case "周日":
                System.out.println("郁郁寡欢、准备上班");
                break;
            default:
                System.out.println("数据有误！");
        }
    }
}

package com.itheima.branch;
/**
 * 目标：清楚switch的注意点。并在开发的时候注意。
 * */
public class SwitchDemo3 {
    public static void main(String[] args) {
        // 表达式类型只能是byte、short、int、char，JDK5开始支持枚举，JDK7开始支持String、不支持double、float、long。
        //double a = 0.1 + 0.2;
        //System.out.println(a);
        long lg = 20;
//      switch (lg){

//      }

        // case给出的值不允许重复，且只能是字面量，不能是变量。
        switch (3){
            case 31:
                break;
            case 3:
                break;
        }

        // 不要忘记写break，否则会出现穿透现象。
        String weekday = "周二";
        switch (weekday){
            case "周一":
                System.out.println("埋头苦干，解决bug ");
                break;
            case "周二":
                System.out.println("请求大牛程序员帮忙");
                //break;
            case "周三":
                System.out.println("今晚啤酒、龙虾、小烧烤");
                //break;
            case "周四":
                System.out.println("主动帮助新来的女程序解决bug");
                break;
            case "周五":
                System.out.println("今晚吃鸡");
                break;
            case "周六":
                System.out.println("与王婆介绍的小芳相亲");
                break;
            case "周日":
                System.out.println("郁郁寡欢、准备上班");
                break;
            default:
                System.out.println("数据有误！");
        }
    }
}

package com.itheima.branch;
/**
 * 需求：用户输入月份可以展示该月份的天数。
 * */
public class SwicthDemo4 {
    public static void main(String[] args) {
        // 1、3 、5、 7 、 8、 10、 12月份是 31天
        // 2月份是闰年为29天、非闰年为28天。
        // 4 、6 、9、 11月份 是30天
        int month = 7;
        switch (month){
            case 1:
            case 3:
            case 5:
            case 7:
            case 8:
            case 10:
            case 12:
                System.out.println(month +"是31天！");
                break;
            case 2:
                System.out.println(month +"月闰年为29天、非闰年为28天！");
                break;
            case 4:
            case 6:
            case 9:
            case 11:
                System.out.println(month +"是30天！");
                break;
            default:
                System.out.println("数据有误！");
        }
    }
}

33：for循环

package com.itheima.loop;
/**
 * 目标：学会使用for循环，并理解它的执行流程。
 * */
public class ForDemo1 {
    public static void main(String[] args) {
        // 需求：输出3次HelloWorld
        for (int i = 0; i < 3; i++) {
            System.out.println("HelloWorld");
        }

        System.out.println("---------------------");
        for (int i = 0; i < 5; i++) {
            System.out.println("HelloWorld");
        }

        System.out.println("---------------------");
        for (int i = 1; i < 5; i++) {
            System.out.println("HelloWorld");
        }

        System.out.println("---------------------");
        for (int i = 1; i <= 5; i++) {
        }
        System.out.println("---------------------");
        for (int i = 1; i <= 5; i+=2) {
            System.out.println("HelloWorld");
        }
    }
}

package com.itheima.loop;
/**
 * 需求：计算1-5的和
 * */
public class ForTest2 {
    public static void main(String[] args) {
        // 2、定义一个整数变量用于累加数据求和
        int sum = 0;
        // 1、定义一个for循环找到 1 2 3 4 5
        for (int i = 1; i <= 5 ; i++) {
            // i = 1 2 3 4 5
            // 3、把循环的数据累加给sum变量
            /**
               等价于： sum = sum + i
               i == 1  sum = 0 + 1
               i == 2  sum = 1 + 2
               i == 3  sum = 3 + 3
               i == 4  sum = 6 + 4
               i == 5  sum = 10 + 5
             */
            sum += i;
        }
        System.out.println("1-5的和是：" + sum);
    }
}

package com.itheima.loop;
/**
 * 需求：求1-0的奇数和
 * */
public class ForTest3 {
    public static void main(String[] args) {
        // 3、定义一个求和的变量 累加奇数和
        int sum = 0;
        // 1、定义一个循环找到 1 2 3...10
        for (int i = 1; i <= 10; i++) {
            // i  1 2 3 4 5 6 7 8 9 10
            // 2、筛选出奇数
            if(i % 2 == 1){
                // i = 1 3 5 7 9
                sum += i;
            }
        }
        // 4、输出求和变量即可
        System.out.println("1-10的奇数和是：" + sum);

        System.out.println("-------------------");
        // 2、定义一个求和的变量 累加奇数和
        int sum1 = 0;
        // 1、定义循环找到 1 3 5 7 9
        for (int i = 1; i <= 10; i+=2) {
            // i = 1 3 5 7 9
            sum1 += i;
        }
        // 3、输出求和变量即可
        System.out.println("1-10的奇数和是：" + sum1);
    }
}

package com.itheima.loop;
/**
 * 需求：找出水仙花数并输出
 * */
public class ForTest4 {
    public static void main(String[] args) {
        // 在循环外定义一个变量用于记录水仙花的个数
        int count = 0;
        // 1、定义一个for循环找出全部三位数
        for (int i = 100; i <= 999; i++) {
            // 2、判断这个三位数是否满足要求
            // i = 157
            // 个位
            int ge = i % 10;
            // 十位
            int shi = i / 10 % 10;
            // 百位
            int bai = i / 100;
            if( (ge*ge*ge + shi * shi * shi + bai * bai * bai) == i){
                System.out.print(i+"\t");
                count++;
            }
        }
        System.out.println(); // 换行！
        System.out.println("水仙花个数是：" + count);
    }
}

34：while循环

什么时候用for循环，什么时候用while循环：
    功能上是完全一样的，for能解决的while也能解决，反之亦然。
    使用规范是：知道循环几次：使用for；不知道循环几次建议使用：while

package com.itheima.loop;
/**
 * 目标：学会使用while循环，并理解它的流程
 * */
public class WhileDemo5 {
    public static void main(String[] args) {
        int i = 0;
        while (i < 3){
            System.out.println("Hello World");
            i++;
        }
        System.out.println("----------------------");
        int j = 0;
        while (j < 3){
            System.out.println("Hello World");
        }
    }
}

package com.itheima.loop;
/**
 * 需求：珠穆朗峰高度是8848860 纸张厚度 0.1 折叠纸张直到不低于珠穆朗峰位置，求折叠几次
 * */
public class WhileTest6 {
    public static void main(String[] args) {
        // 1、定义变量记录山峰的高度 纸张的厚度
        double peakHeight = 8848860;
        double paperThickness = 0.1;

        // 3、定义一个变量用于记录纸张折叠的次数
        int count = 0;

        // 2、定义一个while循环控制纸张进行折叠
        while (paperThickness < peakHeight){
            // 让纸张的厚度多一倍
            paperThickness *= 2;
            count++;
        }
        System.out.println("折叠的次数：" + count);
        System.out.println("纸张的最终厚度：" + paperThickness);
    }
}

35：do-while循环

三种循环的区别小结：for/whike/do-while
    for循环 和 while循环（先判断后执行）
    do...while （第一次先执行后判断）

    for循环和while循环的执行流程是一模一样的。
    如果已知循环次数建议使用for循环，如果不清楚要循环多少次建议使用while循环。
    for循环中，控制循环的变量只在循环中可以使用。While循环中，控制循环的变量在循环后还可以继续使用。

package com.itheima.loop;
/**
 * 目标：学会使用dowhile循环，并理解其执行流程
 * */
public class DoWhileDemo7 {
    public static void main(String[] args) {
        int i = 0;
        do {
            System.out.println("Hello World");
            i++;
        }while (i < 3);

        System.out.println("--------------------");
        for (int j = 0; j < 3; j++) {
            System.out.println("Hello World");
        }
        for (int j = 0; j < 3; j++) {
            System.out.println("Hello World");
        }

        int n = 0;
        while (n < 3){
            System.out.println("Hello World");
            n++;
        }
        System.out.println(n);
    }
}

36：死循环的经典写法

死循环
一直循环的执行下去，如果没有干预不会停止下来：
for(;;) {   
　　System.out.println("Hello World");}
// 经典做法
while(true) {    
　　System.out.println("Hello World");}

do {   
　　System.out.println("Hello World");} while (true);

package com.itheima.loop;

import java.util.Scanner;
/**
 * 目标：学会定义死循环。
 * */
public class DeadForDemo8 {
    public static void main(String[] args) {
//        for ( ; ; ) {
//            System.out.println("Hello World~~~~");
//        }

        // 经典写法
//        while (true) {
//            System.out.println("我是快乐的死循环~~~~");
//        }

//        do{
//            System.out.println("我是快乐的死循环~~~~");
//        }while (true);
        System.out.println("-----------------------------");

        // 1、定义正确的密码
        int okPassword = 520;
        // 2、定义一个死循环让用户不断的输入密码认证
        Scanner sc = new Scanner(System.in);
        while (true) {
            System.out.println("请您输入正确的密码：");
            int password = sc.nextInt();
            // 3、使用if判断密码是否正确
            if(password == okPassword){
                System.out.println("登录成功了~~~");
                break; // 可以理解结束当前所在循环的执行的
            }else {
                System.out.println("密码错误！");
            }
        }
    }
}

package com.itheima.loop;
/**
 * 目标：理解嵌套循环的执行流程
 * */
public class ForForDemo9 {
    public static void main(String[] args) {
        // 场景：假如你有老婆，然后你犯错了，你老婆罚你说5天，每天3句我爱你。
        for (int i = 0; i < 5; i++) {
            for (int j = 0; j < 3; j++) {
                System.out.println("我爱你");
            }
            System.out.println("--------------");
        }

        /**
            *****
            *****
            *****
            *****
         */
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 5; j++) {
                System.out.print("*");
            }
            System.out.println(); // 换行
        }
    }
}

37：break 和 continue 关键字的使用

跳转控制语句介绍
　　break   :  跳出并结束当前所在循环的执行
　　continue:  用于跳出当前循环的当次执行，进入下一次循环

break : 只能用于结束所在循环, 或者结束所在switch分支的执行。
continue : 只能在循环中进行使用

package com.itheima.loop;
/**
 * 目标：理解break 和 continue的作用。
 * */
public class BreakAndContinueDemo10 {
    public static void main(String[] args) {
        // 场景：假如你又有老婆了，然后你犯错了，你老婆罚你做5天家务，每天都是洗碗。
        // 但是洗碗到第三天后心软了 原谅你了不用洗了
        for (int i = 0; i < 5; i++) {
            System.out.println("快乐的洗碗~~~~");
            if(i == 2) {
                break; // 跳出并结束当前循环的执行~~
            }
        }

        // continue 跳出当前循环的当次执行，进入循环的下一次
        // 场景：假如你又有老婆了，然后你犯错了，你老婆罚你做5天家务，
        // 每天都是洗碗。但是洗碗到第三天后心软了 原谅你了不用洗了 但是依然不解恨 继续洗第4天 5天
        for (int i = 1; i <= 5 ; i++) {
            if(i == 3){
                continue; // 立即跳出当次执行，进入循环的下一次！
            }
            System.out.println("洗碗：" + i);
        }
    }
}

package com.itheima.loop;
/**
 * 目标:理解break和continue操作外部循环：直接结束两层循环
 * */
public class BreakAndContinueDemo11 {
    public static void main(String[] args) {
        // 目标:理解break和continue操作外部循环。
        // 场景：假如你有老婆，你老婆罚你说3天，每天5句我爱你，但是说到第二天的第3句就心软了，以后都不用说了！
        OUT:
        for (int i = 1; i <= 3; i++) {
            for (int j = 1; j <= 5; j++) {
                System.out.println("我爱你~~");
                if(i == 2 && j == 3){
                    break OUT; // 指定跳出外部循环，并结束外部循环了！
                }
            }
            System.out.println("-----------------");
        }

        System.out.println("====================================================");
        // continue可以指定结束外部循环的当次执行，进入外部循环的下一次执行
        // 场景：假如你有老婆，你老婆罚你说3天，每天5句我爱你，但是说到第二天的第3句就心软了，当天
        // 不用说了，但是依然不解恨，第3天还是要说的。
        OUT:
        for (int i = 1; i <= 3; i++) {
            for (int j = 1; j <= 5; j++) {
                System.out.println("我爱你~~");
                if(i == 2 && j == 3){
                    continue OUT;
                }
            }
            System.out.println("-----------------");
        }
    }
}

38：Random随机技术

Random随机数类生成需要几步，具体是什么样的？
　　导包：import java.util.Random;
　　Random r = new Random();
　　int number = r.nextInt(10);

Random随机数如何生成 65 – 91之间的随机数？
　　65 – 91  => （0 - 26）+ 65
　　int number = r.nextInt(27) + 65;

package com.itheima.random;

import java.util.Random;
/**
 * 目标：学会使用Java提供的随机数类Random
 * */
public class RandomDemo1 {
    public static void main(String[] args) {
        // 1、导包
        // 2、创建随机数对象
        Random r = new Random();

        // 3、调用nextInt功能（方法）可以返回一个整型的随机数给你
        for (int i = 0; i < 20; i++) {
            int data = r.nextInt(10); // 0 - 9 不包含10的（包前不包后）
            System.out.println(data);
        }

        System.out.println("-----------------------");
        // 1 - 10 ==> -1 ==> (0 - 9) + 1
        int data = r.nextInt(10) + 1;
        System.out.println(data);

        // 3 - 17 ==> -3 ==> (0 - 14) + 3
        int data1 = r.nextInt(15) + 3;
        System.out.println(data1);
    }
}

package com.itheima.random;

import java.util.Random;
import java.util.Scanner;

public class RamdomTest2 {
    public static void main(String[] args) {
        // 1、随机一个幸运号码 1- 100之间  (0 - 99) + 1
        Random r = new Random();
        int luckNumber = r.nextInt(100) + 1;

        // 2、使用一个死循环让用户不断的去猜测，并给出提示
        Scanner sc = new Scanner(System.in);
        while (true) {
            // 让用户输入数据猜测
            System.out.println("请您输入猜测的数据（1-100）：");
            int guessNumber = sc.nextInt();

            // 3、判断这个猜测的号码与幸运号码的大小情况
            if(guessNumber > luckNumber){
                System.out.println("您猜测的数据过大~");
            }else if(guessNumber < luckNumber){
                System.out.println("您猜测的数据过小");
            }else {
                System.out.println("恭喜您，猜中了，可以去买单了~~~");
                break; // 直接跳出并结束当前死循环！！
            }
        }
    }
}