二、Java运算符和选择语句 ★ ✔【模块二、三】（算术运算符、赋值运算符、位运算符、关系运算符、逻辑运算符、三元运算符、）

运算符&选择语句

今日目标：

• 能够知道每种运算符的作用及使用特点
• 能够理解+操作的三种情况
• 能够知道顺序结构语句的执行流程
• 能够使用Debug查看程序的执行流程
• 能够根据需求选择合适的if语句实现
• 能够知道switch语句执行流程和注意事项

1：运算符

前面我们学过了通过字面量和变量来表示一个数据，这里呢，我们来学习对数据进行运算。而对数据运算就要用到我们这里要讲解的运算符，而在讲解具体的运算符之前，我们对运算符和表达式做一个简单的描述：

运算符：对字面量或者变量进行操作的符号

表达式：用运算符把字面量或者变量连接起来符合java语法的式子就可以称为表达式。不同运算符连接的表达式体现的是不同类型的表达式。

举例说明：

int a = 10;

int b = 20;

int c = a + b;

+ ：是运算符，是算术运算符

a + b：是表达式，由于+是算术运算符，所以这个表达式叫算术表达式

知道了什么是运算符和表达式以后，我们来说一下这一块的课程安排：

总共要学习5种类型的运算符，后三种标记为灰色了，我们是在哪里用就在哪里学习。这里我们先学习前两种，首先我们来学习算术运算符

1.1 算术运算符 （(a / b);//1.5? 1）★

Java中的算术运算符有如下几种：

了解了Java中的算术运算符之后，下面我们到IDEA中去使用一下：

/*
    算术运算符
 */
public class OperatorDemo {
    public static void main(String[] args) {
        //定义两个int类型的变量
        int a = 6;
        int b = 4;

        System.out.println(a + b);//10
        System.out.println(a - b);//2
        System.out.println(a * b);//24
        System.out.println(a / b);//1.5? 1
        System.out.println(a % b);//2

        //整数相除只能得到整数，要想得到小数，必须有浮点数的参与
        System.out.println(6.0 / 4);
    }
}

最后，我们来总结一下，刚才在演示代码的时候有两个注意事项：

讲解完毕后，大家赶快动手练习一下吧。

1.2 案例数值拆分

需求：定义一个三位数，将其拆分为个位、十位、百位后，输出在控制台

什么意思呢？下面我们举例来说明一下：

举例：int number = 123；

在控制台输出结果：

​ 个位是：3

​ 十位是：2

​ 百位是：1

知道了要做什么后，下面我们来分析一下如何获取个位，十位，百位：

分析：

① 个位的计算：数值 % 10

​ 123 除以 10（商12，余数为3）

② 十位的计算：数值 / 10 % 10

​ 123 除以 10 （商12，余数为3，整数相除只能得到整数）

​ 12 除以 10 （商1，余数为2）

③ 百位的计算：数值 / 10 / 10 % 10

​ 123 / 10 / 10 % 10（123 / 10 得到12，12 / 10 得到1，1 % 10 得到 1）

分析完毕之后，下面我们到IDEA中去实现一下：

/*
    需求：定义一个三位数，将其拆分为个位、十位、百位后，输出在控制台
 */
public class OperatorTest {
    public static void main(String[] args) {
        //定义一个三位数
        int number = 123;

        //获取个，十，百位数据
        int ge = number % 10;
        int shi = number / 10 % 10;
        int bai = number / 100 % 10;

        //输出结果
        System.out.println("个位是：" + ge);
        System.out.println("十位是：" + shi);
        System.out.println("百位是：" + bai);
    }
}

讲解完毕后，大家赶快动手练习一下吧。

1.3 +操作的三种情况

1.3.1 数字相加(类型转换)

在Java程序中，数据参与运算，要求类型一致。这里就涉及到了数据的类型转换。而类型转换又分为两种：

1. 隐式转换
2. 强制转换

隐式转换把一个表示数据范围小的数值或者变量赋值给另一个表示数据范围大的变量

强制转换：把一个表示数据范围大的数值或者变量赋值给另一个表示数据范围小的变量

格式：数据类型 变量名 = (目标数据类型)(数值或者变量)

IDEA中代码演示如下：

/*
    数字相加
 */
public class OperatorDemo01 {
    public static void main(String[] args) {
        int a = 10;
        double b = 13.14;
        System.out.println(a + b);

        int c = (int)(a + b);
        System.out.println(c);
//        double d = a + b;

        short s = 10;
        int i = 20;
        int j = s + i;
//        short ss = s + i;

        short ss = (short) (s + i);
    }
}

讲解完毕后，大家赶快动手练习一下吧。

1.3.2 字符相加

来，继续啊，这里我们再来说一下字符参与+操作。

先到IDEA中去讲解，然后再回来总结。

IDEA中代码演示如下：

/*
    字符相加
 */
public class OperatorDemo02 {
    public static void main(String[] args) {
        //定义两个变量
        int i = 10;
        char ch = 'A';//'A'的值是65
        ch = 'a';//'a'的值是97
        ch = '0';//'0'的值是48
        System.out.println(i + ch);
    }
}

代码演示完毕后，回到资料总结：

字符参与+操作，其实就是拿字符在计算机底层对应的数值来进行计算的，这里我们了解一下英文大小写字符和数字字符对应的数据值：

• ‘A’ 65 A-Z是连续的
• ‘a’ 97 a-z是连续的
• ‘0’ 48 0-9是连续的

这里也给大家准备了一张ASCII码表，里面有常用的字符及其对应的数值关系：

1.3.3 字符串相加（数字 + 字符串 转成字符串） ★

接下来，我们继续讲解字符串相加，先到IDEA中去讲解，然后再回来总结。

IDEA中代码演示如下：

/*
    字符串相加
 */
public class OperatorDemo03 {
    public static void main(String[] args) {
        System.out.println("it" + "heima");
        System.out.println("itheima" + 666);
        System.out.println(666 + "itheima");

        System.out.println("itheima" + 6 + 66);
        System.out.println(1 + 99 + "年itheima");
    }
}

代码演示完毕后，回到资料总结：

• 当“+”操作中出现字符串时，这个“+”是字符串连接符，而不是算术运算
  • “zhongguo”+ 666
• 当连续进行“+”操作时，从左到右逐个执行
  • 1 + 9999 + “岁zhongguo”

讲解完毕后，大家赶快动手练习一下吧。

1.4 赋值运算符

short的 s = s + 2 会报错

s += 2不会 所以 += 包含了隐式转换

        s += 2;
        s = s + 2;

下面呢，我们来学习赋值运算符。

Java中的赋值运算符有如下几种：

了解了Java中的赋值运算符之后，下面我们到IDEA中去使用一下：

/*
    赋值运算符
 */
public class OperatorDemo {
    public static void main(String[] args) {
        int a = 10;
        System.out.println("a:" + a);

        // += : 把左边和右边的数据相加，最后把结果赋值给左边
//        a += 20;
        a = a + 20;
        System.out.println("a:" + a);


        //注意：扩展的赋值运算符底层隐含了强制类型转换
        short s = 1;
//        s += 2;
        s = (short) (s + 2);
        System.out.println("s:" + s);
    }
}

最后，我们来总结一下，刚才在演示代码的时候有个注意事项：

讲解完毕后，大家赶快动手练习一下吧。

2：选择语句

来，继续啊，为了控制程序的执行流程，Java 就提供了一些流程控制语句，我们先来举例说明一下：

**顺序结构：**从上往下，依次执行

选择结构：

QQ界面的登录，填写账号和密码正确，展示好友列表界面。填写账号或者密码有误，提示：你输入的账号或密码不正确。

这就是通过选择结构来实现的，实际开发中，类似这种逻辑判断的情况非常常见。

循环结构：

比如说，京东商城中，查询手机数据，京东就会返回给你一堆符合你查询要求的数据。

假如，每一部手机数据的展示需要5行代码，如果最终返回了1000部手机，你就需要编写5000行代码来实现数据展示。

这样就太麻烦了，那么，有没有一种流程语句，能够简化这种操作呢？答案肯定是有的，就是我们的循环结构，它就可以通过一个比较简单的结构来控制我们的手机展示1000次。

比如说，带着这样写就可以了，这就是循环结构。

了解完毕之后，我们来说一下这一块的课程安排：

首先，我们来学习顺序结构

2.1 顺序结构

**顺序结构：**是程序中最简单最基本的流程控制，没有特定的语法结构，按照代码的先后顺序，依次执行

执行流程图：

了解完顺序结构后，下面我们到IDEA中去演示一下：

/*
    顺序结构语句
 */
public class OrderDemo {
    public static void main(String[] args) {
        System.out.println("开始");
        System.out.println("语句A");
        System.out.println("语句B");
        System.out.println("语句C");
        System.out.println("结束");
    }
}

这个比较简单，也没什么好练习的。就不练了，我们继续往下学习。

2.2 Debug的基本使用 ★

为了帮助大家更好的理解程序的执行流程，我们来学习Debug，那什么是Debug呢？

**Debug：**是供程序员使用的程序调试工具，它可以用于查看程序的执行流程，也可以用于追踪程序执行过程来调试程序

它的两大作用，查看程序执行流程，调试程序。由于目前我们每个程序的代码内容还比较少，

所以，今天重点掌握查看程序执行流程，当代码复杂的时候，我们需要通过debug来调试程序。那么，debug操作的流程是什么样子的呢？

在讲解操作流程前，我们来说一下：

Debug，又被称为断点调试，断点其实是一个标记，告诉我们从哪里开始查看

知道了Debug被称为断点调试后，我们来讲一下Debug的操作流程：

① 如何加断点

选择要设置断点的代码行，在行号的区域后面单击鼠标左键即可。如图

② 如何运行加了断点的程序

在代码区域右键Debug执行

③ 看哪里

看Debugger窗口，看Console窗口

④ 点哪里

点(Step Over F8) 开始，点(Stop)结束

⑤ 如何删除断点

选择要删除的断点，单击鼠标左键即可。也就是把第一步的动作，再做一次即可。

总结一下，Debug的使用流程：

①如何加断点：选择要设置断点的代码行，在行号的区域后面单击鼠标左键即可

②如何运行加了断点的程序：在代码区域右键Debug执行

③看哪里：看Debugger窗口，看Console窗口

④点哪里：点(Step Over F8) 开始，点(Stop)结束

⑤如何删除断点：选择要删除的断点，单击鼠标左键即可

讲解完毕后，大家赶快动手练习一下吧。

通过Debug的方式看一下，如下代码的执行流程：

/*
    Debug查看程序执行流程
 */
public class DebugDemo {
    public static void main(String[] args) {
        //定义一个int类型的变量，用来表示价格
        int price = 998;

        //输出变量
        System.out.println(price);

        //修改变量的值
        price = 888;

        //再次输出变量的值
        System.out.println(price);
    }
}

2.3 选择语句之if

选择语句有两种结构：

1. if语句
2. switch语句

这里我们先来学习if语句，它会根据判定的结果（真或假）决定执行某个分支的代码

举例说明一下：

无人驾驶的核心就是需要编写大量的判断逻辑，让车辆的行驶变得更加安全。

了解了交通信号灯的基本逻辑后，下面呢，我们通过if语句来实现过马路的信号灯判断，而if语句呢，有三种格式，这里我们首先来学习第一种格式

2.3.1 if语句格式1

格式：

范例：

执行流程：

了解完if语句格式1之后，下面我们到IDEA中去使用一下：

/*
    if语句格式1
 */
public class IfDemo01 {
    public static void main(String[] args) {
        //定义一个变量，用来表示绿灯的状态
        boolean isGreen = true;
        isGreen = false;

        if(isGreen) {
            System.out.println("绿灯行");
        }
    }
}

讲解完毕后，大家赶快动手练习一下吧。

2.3.2 if语句格式2和格式3

刚才我们通过if语句格式1进行了判断，是绿灯的时候，可以通行，但是不是绿灯的时候，没有告诉我不可以通行啊。所以，这里就产生了if语句的第二种格式，先在代码中演示，再回去总结：

/*
    if语句格式2
 */
public class IfDemo02 {
    public static void main(String[] args) {
        //定义一个变量，用来表示绿灯的状态
        boolean isGreen = true;
        isGreen = false;

        if (isGreen) {
            System.out.println("绿灯行");
        } else {
            System.out.println("不是绿灯，不允许行使");
        }
    }
}

演示完毕后，我们来说一下，if语句格式2：

格式：

范例：

执行流程：

讲解完if语句格式2之后，我们到IDEA中再去看一段代码：

public class IfDemo03 {
    public static void main(String[] args) {
        //定义三个变量，表示交通信号灯的三种状态
        boolean isRed = true;
        boolean isGreen = true;
        boolean isYellow = true;
        
        if (isRed) {
            System.out.println("红灯停");
        }

        if (isGreen) {
            System.out.println("绿灯行");
        }

        if (isYellow) {
            System.out.println("黄灯亮了等一等");
        }
    }
}

很明显，这是不合理的，因为我们把三种状态都设置为true了，而实际生活中，只会有一种状态为true，怎么解决呢多种情况的判断呢？这个时候就产生了if语句的第三种格式，先在代码中演示，再回去总结：

/*
    if语句格式3
 */
public class IfDemo03 {
    public static void main(String[] args) {
        //定义三个变量，表示交通信号灯的三种状态
        boolean isRed = true;
        boolean isGreen = true;
        boolean isYellow = true;

        //红灯
//        isGreen = false;
//        isYellow = false;

        //绿灯
//        isRed = false;
//        isYellow = false;

        //黄灯
//        isRed = false;
//        isGreen = false;

        //出现了故障，信号灯都不亮了
        isRed = false;
        isGreen = false;
        isYellow = false;


        if(isRed) {
            System.out.println("红灯停");
        }else if(isGreen) {
            System.out.println("绿灯行");
        }else if(isYellow) {
            System.out.println("黄灯亮了等一等");
        } else  {
            System.out.println("交通信号灯故障，请在保证安全的情况下通行");
        }
    }
}

演示完毕后，我们来说一下，if语句格式3：

if语句格式3：

格式：

执行流程：

讲解完毕后，大家赶快动手练习一下吧。

2.3.3 案例1(交通信号灯)

需求：交通信号灯由红灯、绿灯、黄灯组成，请通过程序实现不同的信号灯给出不同的提示。

提示信息：红灯停、绿灯行、黄灯亮了等一等

首先，我们来简单的分析一下：

分析：

① 用哪种类型来表示信号灯的三种状态呢？

用int类型来表示信号灯的三种状态(1表示红灯，2表示绿灯，3表示黄灯)

② 用if语句的哪种格式来实现该需求呢？

一般来说：1种情况的判断用if格式1,2种情况的判断用if格式2，多种情况的判断用if格式3

③ if语句判断的表达式该怎么写呢？

int light = 1;

if(light == 1) {…}

==：是关系运算符，用来判断两个数据是否相等，如果相等，结果为true，否则为false

分析完毕后，我们来说一下实现步骤：

实现步骤：

① 定义一个int类型的变量用来表示信号灯的状态(1表示红灯，2表示绿灯，3表示黄灯)

② 用if语句格式3进行多种情况的判断

③ 根据不同的情况给出不同的提示信息

知道了实现步骤，下面我们到IDEA中去实现一下：

/*
    需求：交通信号灯由红灯、绿灯、黄灯组成，请通过程序实现不同的信号灯给出不同的提示。
    提示信息：红灯停、绿灯行、黄灯亮了等一等
 */
public class IfTest01 {
    public static void main(String[] args) {
        //1:定义一个int类型的变量用来表示信号灯的状态(1表示红灯，2表示绿灯，3表示黄灯)
        int light = 1;
        light = 2;
        light = 3;
        light = 4;

        //2:用if语句格式3进行多种情况的判断
        //3:根据不同的情况给出不同的提示信息
        if (light == 1) {
            System.out.println("红灯停");
        } else if (light == 2) {
            System.out.println("绿灯行");
        } else if (light == 3) {
            System.out.println("黄灯亮了等一等");
        } else {
            System.out.println("交通信号灯故障，请在保证安全的情况下通行");
        }
    }
}

讲解完毕后，大家赶快动手练习一下吧。

2.3.4 关系运算符

Java中的关系运算符有如下几种：

了解了Java中的关系运算符之后，下面我们到IDEA中去使用一下：

/*
    关系运算符
 */
public class OperatorDemo01 {
    public static void main(String[] args) {
        //定义三个int类型的变量
        int i = 10;
        int j = 20;
        int k = 10;

        //等于：==
        System.out.println(i == j);//false
        System.out.println(i == k);//true
        System.out.println("--------");

        //不等于：!=
        System.out.println(i != j);//true
        System.out.println(i != k);//false
        System.out.println("--------");

        //大于：>
        System.out.println(i > j);//false
        System.out.println(i > k);//false
        System.out.println("--------");

        //大于等于：>=
        System.out.println(i >= j);//false
        System.out.println(i >= k);//true
        System.out.println("--------");

        //千万不要把==写成了=
        System.out.println(i = j); //20
    }
}

最后，我们来总结一下，刚才在演示代码的时候有两个注意事项：

讲解完毕后，大家赶快动手练习一下吧。

2.3.5 案例2(奇偶数)

需求：给定一个整数，请用程序实现判断该整数是奇数还是偶数，并在控制台输出该整数是奇数还是偶数

提示：偶数是能够被2整除的整数

首先，我们来简单的分析一下：

分析：

① 如何判断一个整数是奇数还是偶数？

整数对2进行取余，余数为0是偶数，否则为奇数

② 用if语句的哪种格式来实现该需求呢？

该整数要么是偶数，要么是奇数，2种情况，所以用if语句格式2

分析完毕后，我们来说一下实现步骤：

实现步骤：

① 定义一个int类型的整数

② 用if语句格式2进行判断

③ 根据是否是偶数给出不同的提示信息

知道了实现步骤，下面我们到IDEA中去实现一下：

/*
    需求：给定一个整数，请用程序实现判断该整数是奇数还是偶数，并在控制台输出该整数是奇数还是偶数
 */
public class IfTest02 {
    public static void main(String[] args) {
        //1:定义一个int类型的整数
        int number = 10;
        number = 9;

        //2:用if语句格式2进行判断
        //3:根据是否是偶数给出不同的提示信息
        if (number % 2 == 0) {
            System.out.println(number + "是偶数");
        } else {
            System.out.println(number + "是奇数");
        }
        
    }
}

讲解完毕后，大家赶快动手练习一下吧。

2.3.6 案例3(手机以旧换新)

需求：张三想买一台7988元的新手机，他的旧手机在二手市场能卖1500元，而手机专卖店推出以旧换新优惠，把他旧手机交给店家，新手机就能够打8折优惠。

为了更省钱，要不要以旧换新？请通过程序告诉张三

首先，我们来简单的分析一下：

分析：

① 计算不使用以旧换新的花费

7988 - 1500

② 计算使用以旧换新的花费

7988 * 0.8

③ 用if语句的哪种格式来实现该需求呢？

if语句格式2

分析完毕后，我们来说一下实现步骤：

实现步骤：

① 定义变量(money1)纪录不使用以旧换新的花费

② 定义变量(money2)纪录使用以旧换新的花费

③ 用if语句格式2进行判断 money1是否大于money2

④ 根据判断结果，给出相应的提示

知道了实现步骤，下面我们到IDEA中去实现一下：

/*
    需求：张三想买一台7988元的新手机，他的旧手机在二手市场能卖1500元，而手机专卖店推出以旧换新优惠，
        把他的旧手机交给店家，新手机就能够打8折优惠。为了更省钱，要不要以旧换新？请通过程序告诉张三
 */
public class IfTest03 {
    public static void main(String[] args) {
        //1:定义变量(money1)纪录不使用以旧换新的花费
        int money1 = 7988 - 1500;

        //2:定义变量(money2)纪录使用以旧换新的花费
        double money2 = 7988 * 0.8;

        //3:用if语句格式2进行判断 money1是否大于money2
        //4:根据判断结果，给出相应的提示
        if (money1 > money2) {
            System.out.println("使用以旧换新更省钱");
        } else {
            System.out.println("不使用以旧换新更省钱");
        }
        
    }
}

讲解完毕后，大家赶快动手练习一下吧。

2.3.7 案例4(你是青年人吗)

需求：给出你的年龄，通过程序判断你是否属于青年人？

提示：世界卫生组织，经过对全球人体素质和平均寿命进行测定，对年龄划分标准作出了新的规定

首先，我们来简单的分析一下：

分析：

① 如何判断一个年龄是否属于青年人？

年龄要大于等于18，并且小于等于65

② 在Java中如何表示并且的关系呢？

age >=18 && age<=65

&&：是逻辑运算符，用来连接两个结果为boolean类型的表达式，都为true，结果为true，否则为false

分析完毕后，我们来说一下实现步骤：

实现步骤：

① 定义一个int类型的变量来表示你的年龄

② 用if语句格式2进行判断看你是否属于青年人

③ 根据是否是青年人给出不同的提示信息

知道了实现步骤，下面我们到IDEA中去实现一下：

/*
    需求：给出你的年龄，通过程序判断你是否属于青年人？
    提示：青年人的年龄范围 18~65
 */
public class IfTest04 {
    public static void main(String[] args) {
        //1:定义一个int类型的变量来表示你的年龄
        int age = 22;
        age = 100;

        //2:用if语句格式2进行判断看你是否属于青年人
        //3:根据是否是青年人给出不同的提示信息
        if(age>=18 && age<=65) {
            System.out.println("你是青年人");
        } else {
            System.out.println("你不是青年人");
        }
        
    }
}

讲解完毕后，大家赶快动手练习一下吧。

2.3.8 逻辑运算符

Java中常用的逻辑运算符有如下几种：

了解了Java中的逻辑运算符之后，下面我们到IDEA中去使用一下：

/*
    逻辑运算符
 */
public class OperatorDemo02 {
    public static void main(String[] args) {
        //定义变量
        int i = 10;
        int j = 20;
        int k = 30;

        //逻辑与：&&
        System.out.println((i>j) && (i>k));//false && false
        System.out.println((i<j) && (i>k));//true && false
        System.out.println((i>j) && (i<k));//false && true
        System.out.println((i<j) && (i<k));//true && true
        System.out.println("-----------------------");

        //逻辑或：||
        System.out.println((i>j) || (i>k));//false || false
        System.out.println((i<j) || (i>k));//true || false
        System.out.println((i>j) || (i<k));//false || true
        System.out.println((i<j) || (i<k));//true || true
        System.out.println("-----------------------");

        //逻辑非：!
        System.out.println(!(i>j));//!false
        System.out.println(!!(i>j));//!!false
        System.out.println(!!!(i>j));//!!!false
        System.out.println(!!!!(i>j));//!!!!false
        
    }
}

讲解完毕后，大家赶快动手练习一下吧。

2.3.9 三元运算符

来，继续啊，下面我们来学习三元运算符：

**格式：**关系表达式 ？表达式1 ：表达式2；

**范例：**a > b ? a : b;

执行流程：

• 首先计算关系表达式的值

• 如果值为true，表达式1的值就是运算结果

  如果值为false，表达式2的值就是运算结果

了解了三元运算符的执行流程后，下面我们到IDEA中去使用一下：

/*
    三元运算符
 */
public class OperatorDemo03 {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;

        int max = a > b ? a : b;

        System.out.println("较大的值是：" + max);
    }
}

讲解完毕后，大家赶快动手练习一下吧。

2.3.10 三元运算符和if语句格式2的区别

这里呢，我们来讲解一下三元运算符和if语句格式2的区别，它们有什么区别呢？我们先到IDEA中进行讲解，然后再回来总结：

/*
    三元运算符和if语句格式2的区别
 */
public class OperatorTest {
    public static void main(String[] args) {
        //定义两个int类型的变量
        int a = 10;
        int b = 20;

        //需求：获取两个数中的较大值
        //if语句实现
//        int max;
//        if (a > b) {
//            max = a;
//        } else {
//            max = b;
//        }
//        System.out.println("较大的值是：" + max);

        if(a > b) {
            System.out.println("较大的值是：" + a);
        }else {
            System.out.println("较大的值是：" + b);
        }

        //三元运算符实现
        int max = a > b? a: b;
        System.out.println("较大的值是：" + max);
    }
}

讲解完毕之后，回来总结一下：

• 如果if语句控制的内容：是用变量纪录数据值，可以通过三元运算符改进

• 如果if语句控制的内容是：是通过输出语句直接输出数据值，无法通过三元运算符改进

好了，关于三元运算符和if语句格式2的区别我们就讲到这里。这个知识大家先了解一下，方便我们后面在适合的场景选择合适的实现方案。

2.4 选择语句之switch

来，继续啊，下面我们来学习选择语句中的switch语句。

格式：

格式说明： ★

执行流程：

了解完switch语句后，下面我们到IDEA中去使用一下：

/*
    switch语句
 */
public class SwitchDemo {
    public static void main(String[] args) {
        //定义一个int类型的变量用来表示信号灯的状态(1表示红灯，2表示绿灯，3表示黄灯)
        int light = 1;
//        light = 2;
//        light = 3;
//        light = 4;

        //用switch语句实现交通信号灯案例
        switch (light) {
            case 1:
                System.out.println("红灯停");
                break;
            case 2:
                System.out.println("绿灯行");
                break;
            case 3:
                System.out.println("黄灯亮了等一等");
                break;
            default:
                System.out.println("交通信号灯故障，请在保证安全的情况下通行");
                break;
        }

    }
}

最后，我们来总结一下，刚才在演示代码的时候有个注意事项：

**注意：**在switch语句中，如果case控制的语句体后面不写break，将出现穿透现象，在不判断下一个case值的情况下，向下运行，直到遇到break，或者整个switch语句结束

1 简答题

1.1 byte b3 = b1 + b2; 有问题

请观察下列代码是否存在问题, 如果有, 请说明原因并改正

byte b1 = 3;		// 第一行
byte b2 = 4;		// 第二行
byte b3 = b1 + b2;  // 第三行
byte b = 3 + 4;		// 第四行

答: 第三行存在问题: b1和b2两个byte类型在相加的时候,会提升为int类型进行运算,提升之后,两个int相加的结果还是int类型,将int类型结果,赋值给byte类型变量,需要强转.
    
解决方案:  byte b3 = (byte)(b1 + b2);

1.2 char类型在和int相加的时候,会提升为int类型

现有代码如下, 请回答打印的结果, 并描述中间的运算过程

int num = 10;
char content = 'a';
int result = num + content;
System.out.println(result);

答: 打印结果为107

原因: char类型在和int相加的时候,会提升为int类型,字符'a'提升为int会查找编码表中的数值表示形式97,97 + 10, 结果为107

1.3 / 和 % 的特点

描述下算数运算符中 , / 和 % 的特点

答:
/ : Java当中整数相除, 结果只能得到整数, 想要带有小数的结果, 需要有小数参与运算
% : 取模, 得到的是除法之后剩下的余数

1.4 要运算结果是2.5, 代码应该怎么改?

现有代码如下, 想要运算结果是2.5, 代码应该怎么改?

int a = 5;
int b = 2;
double c = a / b;

答: (不止一种修改方式)

    方式1 : double c = (a * 1.0) / b;
    方式2 : double c = a / (b * 1.0);
    方式3 : 
            double a = 5;
            int b = 2;
            double c = a / b;
    方式4 : 
            int a = 5;
            double b = 2;
            double c = a / b;
    方式5 :
            double a = 5;
            double b = 2;
            double c = a / b;

1.5 简答题五

现有代码如下, 请回答打印的结果, 并描述中间的运算过程

int a = 10;
double b = 12.3;
a += b;
System.out.println(a);

答: (务必说明原因)

结果: 22
原因: 
	a += b, 就是 10 + 12.3 结果为22.3
	+= : 将累加的结果给符号左边赋值
	22.3需要给符号左边的a变量赋值, 注意+=自带强转效果, a又是int类型, 所以22.3给int类型的a赋值, 有一个强转, 类似于: int a = (int)22.3; 
	小数强转为整数, 砍掉小数点后面的内容, 因此结果是22

1.6 简答题六

请结合下列代码, 描述 if 语句执行流程

if(判断条件1){
	语句体1;
}else if(判断条件2){
	语句体2;
}else if(判断条件3){
	语句体3;
}else{
	语句体n+1;
}

答: 

1. 执行判断条件1, 看其返回结果是true, false
        true : 执行语句体1, 执行完毕后, 结束掉整个的if语句.
        false : 进入第二步
2. 执行判断条件2, 看其返回结果是true, false
        true : 执行语句体2, 执行完毕后, 结束掉整个的if语句.
        false : 进入第三步了
        ...
3. 如果给出的所有判断条件, 都是false, 将会执行最后的else, 语句体n+1;

2 编程题

2.1 编程题目一

训练目标: 掌握数值拆分

需求描述: 自己随意给定一个四位数，然后输出每位数字之和例如：
int j = 1234;
控制台打印: 和是10

public class Test01 {
    public static void main(String[] args) {
        //定义变量
        int i = 1234;
        //数值拆分
        int ge = i % 10;
        int shi = i / 10 % 10;
        int bai = i / 10 / 10 % 10;
        int qian = i / 1000;
        //相加打印
        System.out.println("和是:" + (ge + shi + bai + qian));
    }
}

2.2 编程题目二

训练目标: 掌握数据交换的逻辑

需求描述: 对两个整数变量的值进行互换(使用第三个变量结合赋值运算实现)，请补齐横线处四行代码。

public class Test02 {
    public static void main(String[] args) {
        //定义变量
        int a=5;
        int b=3;
        //交换数据
        int temp = a;
        a = b;
        b = temp;
        //打印结果
        System.out.println("a="+a+",b="+b);  //输出a=3,b=5
    }
}

2.3 编程题目三

训练目标: 掌握三元运算符和选择结构if

需求描述: 自己随意给定3个整数，编程求出最大值(请分别用三元运算符和if选择结构实现)

public class Test03 {
    public static void main(String[] args) {
        int a = 7;
        int b = 12;
        int c = 9;

        //三元
        //int max = (a > b ? a : b) > c ? (a > b ? a : b) : c;
        //System.out.println("max:" + max);

        //if语句1
        if (a > b && a > c) {
            System.out.println("max:" + a);
        }
        if (b > a && b > c) {
            System.out.println("max:" + b);
        }
        if (c > a && c > b) {
            System.out.println("max:" + c);
        }

//        //if语句2
//        //a大于b的同时,也大于c,那么a是max
//        if (a > b) {
//            if (a > c) {
//                System.out.println(a + "是最大值");
//            } else {
//                //如果a大于b的同时,小于c,那么c是max
//                System.out.println(c + "是最大值");
//            }
//        } else {
//            //反之如果b大于a的同时,也大于c,那么b是max
//            if (b > c) {
//                System.out.println(b + "是最大值");
//            } else {
//                //如果b大于a的同时,小于c,那么c是max
//                System.out.println(c + "是最大值");
//            }
//        }
    }
}

2.5 编程题目四

训练目标: 掌握选择语句switch

需求描述: 自己给定一个月份，输出它是哪个季节
3-5月为春季、6-8月为夏季、9-11月为秋季、12-2月为冬季
请使用switch实现

public class Test04 {
    public static void main(String[] args) {
        //定义月份
        int month = 6;
        //switch:case穿透
        switch (month) {
            case 12:
            case 1:
            case 2:
                System.out.println("冬季");
                break;
            case 3:
            case 4:
            case 5:
                System.out.println("春季");
                break;
            case 6:
            case 7:
            case 8:
                System.out.println("夏季");
                break;
            case 9:
            case 10:
            case 11:
                System.out.println("秋季");
                break;
            default:
                System.out.println("月份输入有误!");
                break;
        }

        //switch: JDK14中switch的case新写法
//        switch (month){
//            case 12,1,2:
//                System.out.println("冬季");
//                break;
//            case 3,4,5:
//                System.out.println("春季");
//                break;
//            case 6,7,8:
//                System.out.println("夏季");
//                break;
//            case 9,10,11:
//                System.out.println("秋季");
//                break;
//            default:
//                System.out.println("月份输入有误!");
//                break;
//        }
    }
}

模块二.变量 数据类型转换 运算符

1.字节:计算机存储数据的最小存储单元(byte或者B)
  8bit = 1B -> 往后都是1024
2.常用的dos命令
  a.切换盘符   盘符名:
  b.查看       dir
  c.进入指定文件夹   cd 文件夹名     cd 文件夹名\文件夹名
  d.退到上一级   cd..
  e.退到根目录   cd\
  f.清屏      cls
  g.退出黑窗口   exit
  h.创建文件夹   mkdir 文件夹名      mkdir 文件夹名\文件夹名
  i.删除文件夹   rd 文件夹名     被删除的文件夹必须是空的,删除之后不走回收站
  j.删除文件     del 文件名.后缀名       del *.后缀名 
      
3.jdk和jre以及jvm关系
  jdk包含jre,jre包含jvm
      
4.jvm和跨平台
  想要实现跨平台,就需要在不同的操作系统上安装不同版本的jvm
      
5.环境变量 -> JAVA_HOME
      
6.程序入门
  a.编写:
    public class 类名{
        public static void main(String[] args){
            System.out.println("helloworld");
        }
    }
  b.编译:
    javac java文件名.java
  c.运行:
    java class文件名
        
7.注释:对代码的解释说明
  单行注释: //
  多行注释: /**/
  文档注释: /***/

8.关键字:java提前定义好的,具有特殊含义的小写单词,在高级记事本中颜色特殊
    
9.常见问题
  a.编码问题:写代码以及运行遵守的编码要一致
  b.java文件名和类名一致问题
    带public的类类名要和java文件名一致
    一个java文件中最好写一个类
     
      
10.println和print区别
   相同点:都是输出语句
   不同点:println自带换行效果,print不带换行效果
       
第二大模块重点:常量 变量 类型转换 进制的转换
  1.常量的使用
  2.变量的使用
  3.会强制类型转换

第一章.常量

1.概述:在代码的运行过程中,值不会发生改变的数据
2.分类:
  整数常量:所有整数
  小数常量:所有带小数点的
          2.5  1.5  2.0
  字符常量:带单引号的 ''  单引号中必须有且只能有一个内容
          '1'(算)   '11'(不算)   ''(不算)  'a1'(不算)
          ' '(算)   '  '(两个空格不算)
          '写一个tab键'(算)
      
  字符串常量:带双引号的 ""  双引号中内容随意
            ""   "helloworld"

  布尔常量:true(真) false(假) -> 这两个单词不要加双引号
          "true"(这样写属于字符串,不属于布尔常量)
      
  空常量:null  代表的是数据不存在    

public class Demo01Constant{
	public static void main(String[] args){
		//整数常量
		System.out.println(1);
		System.out.println(-1);
		
		//小数常量
		System.out.println(1.5);
		System.out.println(1.0);
		
		//字符常量   单引号中必须有且只能有一个内容
		System.out.println('1');
		//System.out.println('11');错误
		System.out.println(' ');//一个空格算一个内容
		//System.out.println('    ');//四个空格算四个内容,所以不属于字符常量
		System.out.println('	');//tab键算一个内容
		
		//字符串常量
		System.out.println("本人是尚硅谷第一帅的男人");
		System.out.println("");
		
		//布尔常量
		System.out.println(true);
		System.out.println(false);
		
		//空常量 不能直接使用
		//System.out.println(null);
	}
}

public class Demo02Constant{
	public static void main(String[] args){
		System.out.println(10+3);//13
		System.out.println(10-3);//7
		System.out.println(10*3);//30
		/*
		  /前后如果都是整数,结果只取整数部分
		  
		  /前后只要有一个数带小数点,结果就是正常小数了
		*/
		System.out.println(10/3);//3
		System.out.println(10.0/3);
		System.out.println(10/3.0);
	}
}

第二章.变量

数据类型	关键字	内存占用	取值范围
字节型	byte	1个字节	-128 至 127 定义byte变量时超出范围,废了
短整型	short	2个字节	-32768 至 32767
整型	int（默认）	4个字节	-231 至 231-1 正负21个亿 -2147483648——2147483647
长整型	long	8个字节	-263 至 263-1 19位数字 -9223372036854775808到9223372036854775807
单精度浮点数	float	4个字节	1.4013E-45 至 3.4028E+38
双精度浮点数	double（默认）	8个字节	4.9E-324 至 1.7977E+308
字符型	char	2个字节	0 至 216-1
布尔类型	boolean	1个字节	true，false(可以做判断条件使用)

1.变量的介绍以及使用

1.变量的数据类型:
  基本数据类型:4类8种
      整型:byte short int long
      浮点型:float double
      字符型:char
      布尔型:boolean
          
  引用数据类型: 类 数组 接口 枚举 注解
      
2.概述:在代码的运行过程中,值会随着不同的情况而随时发生改变的数据
    
3.作用:一次接收一个数据
       将来定义一个变量,接收一个值,后续可能会根据不同的情况对此值进行修改,此时可以用变量
    
4.定义:
  a.数据类型 变量名 = 值;

  b.数据类型 变量名;
    变量名 = 值;

  c.连续定义三个相同类型的变量
    数据类型 变量名1,变量名2,变量名3;
    变量名1 = 值;
    变量名2 = 值;
    变量名3 = 值;

    比如:int i,j,k;
         i = 10;
         j = 20; 
         k = 30;


    数据类型 变量名1 = 值,变量名2 = 值,变量名3 = 值;
    比如: int i = 10,j = 20,k = 30;

    正确读法:先看等号右边的,再看等号左边的 -> 将等号右边的数据赋值给等号左边的变量
            哪怕等号右边有运算,我们都得先将等号右边的运算算出一个值来,最后赋值给等号左边的变量
        
5.注意:
  a.字符串不属于基本数据类型,属于引用数据类型,用String表示
    String是一个类,只不过字符串在定义的时候可以和基本数据类型格式一样
      
6.float和double的区别:
  a.float的小数位只有23位二进制,能表示的最大十进制为2的23次方(8388608),是7位数,所以float型代表的小数,小数位能表示7位
      
  b.double的小数位只有52位二进制,能表示的最大十进制为(4 503 599 627 370 496),是16位数,所以double型代表的小数,小数位能表示出16位
      
      
7.切记:将来开发不要用float或者double直接参与运算,因为直接参与运算会有精度损失问题    

public class Demo03Var{
	public static void main(String[] args){
		//byte
		byte num1 = 100;
		System.out.println(num1);
		
		//short
		short num2 = 1000;
		num2 = 1001;
		System.out.println(num2);
		
		//int  整数的默认类型
		int num3 = 10000;
		num3 = 1;
		System.out.println(num3);
		
		//long -> 定义long型的变量后面加个L
		long num4 = 10L;
		System.out.println(num4);
		
		//float -> 定义float型变量的时候后面加个F
		float num5 = 2.5F;
		System.out.println(num5);
		
		//double -> 小数的默认类型
		double num6 = 2.5;
		System.out.println(num6);
		
		//char
		char num7 = 'A';
		System.out.println(num7);
		
		//boolean
		boolean num8 = true;
		boolean num9 = false;
		
		/*
		   num9 = false
		   num8 = num9 -> 将num9的值赋值给num8 -> 相当于num8 = false
		*/
		num8 = num9;
		System.out.println(num8);
		
		//String -> 是一个引用数据类型,属于类的一种,但是定义和基本类型一致
		String name = "金莲";
		System.out.println(name);
	}
}

public class Demo04Var{
	public static void main(String[] args){
		int num1 = 10;
		int num2 = 3;
		
		int sum = num1+num2;
		System.out.println(sum);//13
		
		int sub = num1-num2;
		System.out.println(sub);//7
		
		//System.out.println(num1*num2);//30
		int mul = num1*num2;
		System.out.println(mul);//30
		
		/*
		  由于/前后都是整数,结果取整数部分,结果还赋值给一个整数变量
		*/
		int div = num1/num2;
		System.out.println(div);//3
		
		double div1 = num1/num2;//3.0
		System.out.println(div1);
	}
}

public class Demo05Var{
	public static void main(String[] args){
		/*
		  转义字符:  \
		  
		  可以这样简单理解:
		    a.将普通字符转成具有特殊含义的字符
			b.将具有特殊含义的字符转成普通字符
		
		*/
		
		
		/*
		   n:普通字符
		   \n:换行符
		*/
		
		System.out.print("春眠不觉晓\n");
		System.out.print("处处闻啼鸟\n");
		System.out.print("夜来风雨声\n");
		System.out.print("花落知多少\n");
		
		/*
		   t:普通字符
		   \t:制表符 -> 就是tab键
		*/
		System.out.println("本人\t是尚硅谷第一帅");
		
		
		/*
		  用String表示一个路径
		  在java中两个\\代表一个\
		*/
		
		String path = "E:\\01_javase_video\\code";
		System.out.println(path);
	}
}

public class Demo06Var{
	public static void main(String[] args){
		float a = 10;
		float b = 3;
		
		float result = a/b;
		System.out.println(result);//3.3333333
		
		
		double c = 10;
		double d = 3;
		double result02 = c/d;
		System.out.println(result02);//3.3333333333333335
		
		
		float x = 3.55F;
		float y = 2.12F;
		
		float result03 = x-y;
		System.out.println(result03);//1.4300001
		
	}
}

2.变量使用时的注意事项

1.变量不初始化(第一次赋值)不能直接使用
2.在同一个作用域(一对大括号就是一个作用域)中不能定义重名的变量 
3.不同作用域中的数据尽量不要随意互相访问
  在小作用域中能直接访问大作用域中的变量
  在大作用域中不能直接访问小作用域中的变量

public class Demo07Var{
	public static void main(String[] args){
		int i = 10;
		System.out.println(i);
		
		int j;
		
		j = 10;
		System.out.println(j);
		
		int k = 10;
		//int k = 20;//只要是变量名前带具体的数据类型就是重新定义
		System.out.println(k);
		
		{
		   int x = 1000;
           System.out.println(k);		   
		}
		
		//System.out.println(x);	
		
	}
}

3.练习

定义一个人类,用变量表示 姓名 性别 年龄 身高 体重

public class Demo08VarPerson{
	public static void main(String[] args){
		//姓名
		String name = "张三";
		//性别
		char sex = '男';
		//年龄
		int age = 20;
		//身高
		double height = 175.5;
		//体重
		double weight = 145.5;
		
		System.out.println(name);
		System.out.println(sex);
		System.out.println(age);
		System.out.println(height);
		System.out.println(weight);
	}
}

第三章.标识符

1.概述:咱们给类,方法,变量取的名字
2.注意:
  a.硬性规定(必须遵守)
    标识符可以包含"英文字母","数字","$和_"
    标识符不能以数字开头  int i1 = 100(正确)  int 1i = 100(错误)
    标识符不能是关键字  int static = 100(错误)   int public = 100(错误)
      
  b.软性建议(可遵守可不遵守,但是建议遵守)
    给类取名字:遵循大驼峰式 -> 每个单词首字母大写
    给方法和变量取名字:遵循小驼峰式 -> 从第二个单词开始往后首字母大写
   
    见名知意

第四章.数据类型转换

1.什么时候发生类型转换:
  a.等号左右两边类型不一致
  b.不同类型的数据做运算
      
2.分类:
  a.自动类型转换
    将取值范围小的数据类型赋值给取值范围大的数据类型 -> 小自动转大
    取值范围小的数据类型和取值范围大的数据类型数据做运算 -> 小自动转大
      
  b.强制类型转换
    当将取值范围大的数据类型赋值给取值范围小的数据类型 -> 需要强转
      
3.基本类型中按照取值范围从小到大排序:
  byte,short,char -> int -> long -> float -> double     

1.自动类型转换

1.将取值范围小的数据类型赋值给取值范围大的数据类型 -> 小自动转大
2.取值范围小的数据类型和取值范围大的数据类型做运算 -> 小自动转大    

public class Demo09DataType{
	public static void main(String[] args){
		/*
		  等号右边是整数,整数默认类型为int
		  等号左边是long型的变量
		  
		  将取值范围小的数据类型赋值给取值范围大的数据类型,发生了自动类型转换
		*/
		long num1 = 100;
		System.out.println(num1);
		
		
		int i = 10;
		double b = 2.5;
		
		/*
		   double = int+double
		   double  = double+double
		   int自动提升为了double,发生了自动类型转换
		*/
		double sum = i+b;
		System.out.println(sum);
	}
}

2.强制类型转换

1.将取值范围大的数据类型赋值给取值范围小的数据类型
  取值范围小的数据类型 变量名 = 取值范围大的数据类型 -> 需要强转
    
2.怎么强转:
  取值范围小的数据类型 变量名 = (取值范围小的数据类型)取值范围大的数据类型

public class Demo10DataType{
	public static void main(String[] args){
		/*
		  等号右边的数据是小数,小数默认类型为double
		  等号左边的变量是float型
		  
		  将取值范围大的赋值给取值范围小 -> 报错,需要强转
		*/
		//float num1 = 2.5;
		//float num1 = (float)2.5;
		float num1 = 2.5F;
		System.out.println(num1);
		
	}
}

3.强转的注意事项

1.不要随意写成强转的格式,因为会有精度损失问题以及数据溢出现象,除非没有办法
2.byte,short定义的时候如果等号右边是整数常量,如果不超出byte和short的范围,不需要我们自己强转,jvm自动转型  
    
  byte,short如果等号右边有变量参与,byte和short自动提升为int,然后结果再次赋值给byte或者short的变量,需要我们自己手动强转
    
    
3.char类型数据如果参与运算,会自动提升为int型,如果char类型的字符提升为int型会去ASCII码表(美国标准交换代码)范围内去查询字符对应的int值,如果在ASCII码表范围内没有对应的int值,回去unicode码表(万国码)中找  

public class Demo11DataType{
	public static void main(String[] args){
		//精度损失
		int i = (int)2.9;
		System.out.println(i);
		
		/*
		  数据溢出
		  int型占内存4个字节,4个字节变成二进制是32位
		  
		  100个亿: 10 0101 0100 0000 1011 1110 0100 0000 0000 -> 34位二进制
		  
		  100个亿的二进制位比int型的二进制位多出来2位,此时干掉最前面的2位
		  
		  101 0100 0000 1011 1110 0100 0000 0000
		  
		  101 0100 0000 1011 1110 0100 0000 0000->1410065408
		*/
		int j = (int)10000000000L;
		System.out.println(j);//1410065408
		
	    System.out.println("=========================");
		
		byte b = 10;
		System.out.println(b);
		
		b = (byte)(b+1);
		System.out.println(b);
		
		System.out.println("=========================");
		
		char c = '中';
		System.out.println(c+0);//20013
	}
}

第五章.进制的转换(了解)

十进制	二进制	八进制	十六进制
0	0	0	0
1	1	1	1
2	10	2	2
3	11	3	3
4	100	4	4
5	101	5	5
6	110	6	6
7	111	7	7
8	1000	10	8
9	1001	11	9
10	1010	12	a或A
11	1011	13	b或B
12	1100	14	c或C
13	1101	15	d或D
14	1110	16	e或E
15	1111	17	f或F
16	10000	20	10

3.1 十进制转成二进制

辗转相除法 -> 循环除以2,取余数

3.2 二进制转成十进制

8421规则

<

3.3 二进制转成八进制

将二进制数分开  (3位为一组)

<

3.4 二进制转成十六进制

 将二进制数分组-> 4位为一组

<

第六章.位运算符(了解)

1.符号的介绍:
  a. &(与) -> 有假则假
  b. |(或) -> 有真则真
  c. ~(非) -> 取反
  d. ^(异或) -> 符号前后结果一样为false,不一样为true
     true ^ true -> false
     false ^ false -> false
     true ^ false -> true
     false ^ true -> true
      
2.   1代表true   0代表false  
      
3.我们要知道计算机在存储数据的时候都是存储的数据的补码,计算也是用的数据的补码 
  但是我们最终看到的结果是原码换算出来的
      
  原码   反码   补码
      
4.正数二进制最高位为0;  负数二进制最高位为1
    
5.如果是正数  原码 反码 补码 一致
  比如:5的原码  反码  补码一致:
      0000 0000 0000 0000 0000 0000 0000 0101 -> 因为是正数,二进制最高位为0
          
  如果是负数,原码 反码 补码不一样了
       反码是原码的基础上最高位不变,剩下的0和1互换
       补码是在反码的基础上+1
          
  比如:-9
       原码: 1000 0000 0000 0000 0000 0000 0000 1001
       反码: 1111 1111 1111 1111 1111 1111 1111 0110
       补码: 1111 1111 1111 1111 1111 1111 1111 0111

（1）左移：<<

​ 运算规则：左移几位就相当于乘以2的几次方

​ **注意：**当左移的位数n超过该数据类型的总位数时，相当于左移（n-总位数）位

2<<2   结果等于8
快速算法:  2*(2的2次方)

<

-2<<2  等于-8
快速算法: -2*(2的2次方)

<

（2）右移：>>

快速运算：类似于除以2的n次，如果不能整除，向下取整

9>>2  等于2
    
快速算法: 9除以(2的2次方)

<

-9>>2   等于-3
    
快速算法: -9除以(2的2次方)

<

（3）无符号右移：>>>

运算规则：往右移动后，左边空出来的位直接补0，不管最高位是0还是1空出来的都拿0补

正数：和右移一样

9>>>2 等于2

负数：右边移出去几位，左边补几个0，结果变为正数

-9>>>2
结果为:1073741821    

笔试题: 8>>>32位 -> 相当于没有移动还是8

​ 8>>>34位 -> 相当于往右移动2位

（4）按位与：&

小技巧:将0看成为false 将1看成true

运算规则：对应位都是1才为1,相当于符号左右两边都为true,结果才为true

1&1 结果为1

1&0 结果为0

0&1 结果为0

0&0 结果为0

5&3 结果1

<

（5）按位或：|

运算规则：对应位只要有1即为1,相当于符号前后只要有一个为true,结果就是true

1|1 结果1

1|0 结果1

0|1 结果1

0|0 结果0

5|3    结果为7

<

（6）按位异或：^

​ 运算规则：对应位一样的为0,不一样的为1

1^1 结果为0 false

1^0 结果为1 true

0^1 结果为1 true

0^0 结果0 false

5^3   结果为6

<

（7）按位取反

运算规则：~0就是1

​ ~1就是0

~10   结果为-11

<

第七章.运算符的优先级(了解)

<

提示说明：
（1）表达式不要太复杂
（2）先算的使用(),记住,如果想让那个表达式先运行,就加小括号就可以了
i<(n*m)

模块三 idea_运算符

模块二的回顾:
  1.常量:在代码的运行过程中,值不会发生改变的数据
    a.整数常量:所有的整数
    b.小数常量:所有带小数点的  2.0
    c.字符常量:带单引号的,单引号中必须有,且只能有一个内容
    d.字符串常量:带双引号的
    e.布尔常量:true false -> 可以当条件判断使用
    f.空常量:null 代表数据不存在,所以不能直接使用
  2.变量:在代码的运行过程中,会根据不同的情况而随时可以改变的数据
    a.定义:
      数据类型 变量名 = 值 -> 将等号右边的值赋值给等号左边的变量
    b.数据类型:
      基本类型:byte short int long float double boolean char
      引用类型:类 数组 接口 枚举 注解
          
  3.数据类型转换:等号左右两边类型不一致时,或者不同的类型做运算
    a.自动类型转换:小转大
      将取值范围小的类型赋值给取值范围大的类型
      取值范围小的类型和取值范围大的类型之间做运算
    b.强转:大转小
      取值范围小的数据类型 变量名 = (取值范围小的数据类型)取值范围大的数据类型
        
        
模块三的重点:
  all

第一章.IDEA的使用

1.idea的介绍

1.概述:开发工具
2.特点:
  a.idea是java写的,所以本地上必须有正确的jdk环境(JAVA_HOME)
  b.idea自动保存
  c.不用我们打开dos命令窗口执行javac和java命令
  d.idea有强大的快捷键,生成代码,纠错等
  e.idea会自动管理我们写的代码
      
3.相关开发工具:eclipse myeclipse   
    
4.作用:加速我们的开发    

2.idea的目录结构

先创建project,在project下创建module,在module下创建package -> 必须记住

3.Project的操作

3.1.project的创建

3.2再次创建一个新的Project

3.3.关闭Project

file-> close project

3.4.打开project

4.module的操作

4.1.创建module

4.2.关闭module

a.对着要关闭的module右键 -> remove module -> 此时是关闭,不是真正的删除module
b.再对着关闭的module右键-> delete -> 从本地上真正删除

4.3.导入已有的module

5.package的操作

5.1创建

5.2 package的删除

右键-> delete

5.3 package取名字规范

1.公司域名倒着写:
  比如:尚硅谷  域名为:www.atguigu.com
  我们写代码创建包: com.atguigu

6.创建类以及基本语句生成快捷键

1.生成main方法:输入main -> 回车

2.生成输出语句:sout -> 回车

3.将变量名放到输出语句中:

a.变量名.sout

b.变量名.soutv -> 带字符串平拼接格式的输出方式-> 输出格式好看

7.基本设置

7.1设置字体

file-settings

7.2设置提示的快捷键

file-settings

7.3 设置注释字体

8.快捷键

快捷键	功能
Alt+Enter	导入包，自动修正代码(重中之重)
Ctrl+Y	删除光标所在行
Ctrl+D	复制光标所在行的内容，插入光标位置下面
Ctrl+Alt+L	格式化代码
Ctrl+/	单行注释
Ctrl+Shift+/	选中代码注释，多行注释，再按取消注释
Alt+Shift+上下箭头	移动当前代码行

先写等号右边的,可以自动生成等号左边的变量

或者

9.出现的问题

1.在运行代码时会出现"找不到对应的发行源"或者"不支持发行版本"或者"无效的发行源版本",证明本地jdk版本和idea中的language level不匹配
  所以要匹配版本
  file->project Structure->点击project->引入本地jdk->project level选择对应的版本
2.没有out路径的问题
  out路径是专门存放idea自动编译生成的.class文件的
  所以需要指明out路径
    
3.src是灰色的,对着src,右键,选项中没有java class或者package
    
4.刚使用,jdk没有配置

第二章.运算符

1.算数运算符

符号	说明
+	加法
-	减法
*	乘法
/	除法 如果符号前后都是整数,结果取整数部分 如果符号前后有一个为小数,结果就是正常小数
%	模,取余数部分

public class Demo01Arithmetic {
    public static void main(String[] args) {
        int i = 10;
        int j = 3;
        int add = i+j;//推荐使用
        System.out.println(add);//13
        System.out.println(i+j);//13

        int sub = i-j;
        System.out.println(sub);//7

        int mul = i*j;
        System.out.println(mul);//30

        int div = i/j;
        System.out.println(div);//3

        int mo = i%j;
        System.out.println(mo);//1
    }
}

+:
  1.运算
  2.字符串拼接:任何类型的数据遇到字符串都会变成字符串,此时+就不再是运算了,而是字符串拼接,将内容直接往后拼接    
 

public class Demo02Arithmetic {
    public static void main(String[] args) {
        int i = 10;
        int j = 3;
        System.out.println(i+j+"");//13
        System.out.println(i+j+""+1);//131
        System.out.println(i+""+j);//103

        System.out.println("i和j相加只和为:"+(i+j));
    }
}

1.2.自增自减运算符(也算算数运算符的一种)

1.格式:
  变量++ -> 后自加
  ++变量 -> 前自加
  变量-- -> 后自减
  --变量 -> 前自减
      
  自增和自减只变化1
      
2.使用:
  a.单独使用: ++ -- 单独为一句,没有和其他的语句掺和使用
    i++;

    符号前在在后都是先运算
        
  b.混合使用: ++ -- 和其他的语句掺和使用了(比如:输出语句,赋值语句)
    符号在前:先运算,在使用运算后的值
    符号在后:先使用原值,使用完毕之后,自身再运算
      

public class Demo03Arithmetic {
    public static void main(String[] args) {
        int i = 10;
        //i++;
        ++i;
        System.out.println("i = " + i);

        System.out.println("==================");

        int j = 100;
        int result01 = ++j;
        System.out.println("result01 = " + result01);//101
        System.out.println(j);//101

        System.out.println("==================");
        int k = 10;
        int result02 = k++;
        System.out.println("result02 = " + result02);
        System.out.println(k);

        System.out.println("==================");

        int z = 100;
        System.out.println(z++);
        System.out.println(z);

        System.out.println("==================");

        int x = 10;
        int y = 20;

        /*
           10+19 = 29
           29+12 = 41

           以后开发肯定不会这么写
         */

        int result03 = x++ + --y + ++x;
        System.out.println("result03 = " + result03);

        System.out.println("=======================");

        int c = 10;
        c = c++;
        System.out.println(c);//10
        System.out.println(c);//10

    }
}

3.赋值运算符

1.基本赋值运算符:
  =  -> 先看等号右边的,再将右边的数据赋值给等号左边的变量
      
2.复合赋值运算符:
  +=:
    int i = 10;
    i+=2 -> i = i+2
       
        
  -=
  *=
  /=  : 取整数部分
  %=  : 取余数部分  
      
3.注意:byte short 遇到复合赋值运算符,jvm会自动转型      

public class Demo01Assignment {
    public static void main(String[] args) {
        int i = 10;
        i+=2;//i = i+2
        System.out.println(i);
    }
}

public class Demo02Assignment {
    public static void main(String[] args) {
        byte b = 10;
        //b = (byte)(b + 1);
        b+=1;//b = b+1
        System.out.println(b);
    }
}

4.关系运算符(比较运算符)

1.结果:boolean型 -> 要么是true,要么是false
2.作用:做条件判断使用    

符号	说明
==	如果符号前后相等为true;否则为false
>	如果符号前的数据大于符号后的数据为true,否则为false
<	如果符号前的数据小于符号后的数据为true,否则为false
>=	如果符号前的数据大于或者等于符号后的数据为true,否则为false
<=	如果符号前的数据小于或者等于符号后的数据为true,否则为false
!=	如果符号前后不相等为true;否则为false

public class Demo01Compare {
    public static void main(String[] args) {
        int i = 10;
        int j = 20;

        boolean result01 = i == j;
        System.out.println("result01 = " + result01);//false
        System.out.println(i>j);//false
        System.out.println(i<j);//true
        System.out.println(i>=j);//false
        System.out.println(i<=j);//true
        System.out.println(i!=j);//true

    }
}

5.逻辑运算符

 1.作用:连接多个boolean结果的
 2.结果:boolean型结果    

符号	说明
&&(与,并且)	有假则假,符号前后有一个结果为false,整体就是false
||(或者)	有真则真,符号前后有一个结果为true,整体就是true
!(非,取反)	不是true,就是false;不是false,就是true
^(异或)	符号前后结果一样为false;不一样为true true^true -> false true^false -> true false^true -> true false^false -> false

public class Demo01Logic {
    public static void main(String[] args) {
        int i = 10;
        int j = 20;
        int k = 10;

        boolean result01 = (i>j) && (i==k);
        System.out.println("result01 = " + result01);//false

        boolean result02 = (i>j) || (i==k);
        System.out.println("result02 = " + result02);//true

        boolean result03 = (i>j) ^ (i==k);//false ^ true
        System.out.println("result03 = " + result03);//true

        boolean result04 = !(i>j) ;
        System.out.println("result04 = " + result04);//true
    }
}

符号	说明
&	1.单与,如果前后都是布尔型,有假则假,但是如果符号前为false,符号后的判断会继续执行 2.如果该符号前后都是数字,看做是位运算符
&&	1.双与,有假则假,但是有短路效果,如果符号前为false,符号后的判断就不会执行了
|	1.单或,如果前后都是布尔型,有真则真,但是如果符号前为true,符号后的判断会继续执行 2.如果该符号前后都是数字,看做是位运算符
||	1.双或,有真则真,但是有短路效果,如果符号前为true,符号后的判断就不会执行了

public class Demo02Logic {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        //boolean result01 = (++a>100)&(++b>10);
        //boolean result01 = (++a > 100) && (++b > 10);

        //boolean result01 = (++a<100)|(++b>10);
        boolean result01 = (++a<100)||(++b>10);
        System.out.println("result01 = " + result01);
        System.out.println("a = " + a);
        System.out.println("b = " + b);
    }
}

问题:定义一个变量(a),随意给一个值,判断这个变量接收的值是否在1-100之间

1<=a<=100 -> 错误,这是数学写法

i>=1 && i<=100 -> java写法,用逻辑运算符拼接多个判断

6.三元运算符

1.格式:
  boolean表达式?表达式1:表达式2
      
2.执行流程:
  先判断,如果是true,就走?后面的表达式1,否则就走:后面的表达式2

6.1练习1

需求:小明考完试了,判断小明的分数是否及格,返回结果

public class Demo01Ternary {
    public static void main(String[] args) {
        //定义一个变量,表示小明的分数
        int score = 60;
        String result = score>=60?"及格":"不及格";
        System.out.println("result = " + result);
    }
}

6.2练习2

有两个老人,年龄分别为70  80  求出两个老人的最高年龄

public class Demo02Ternary {
    public static void main(String[] args) {
        int old1 = 70;
        int old2 = 80;
        
        int max = old1>old2?old1:old2;
        System.out.println("max = " + max);
    }
}

6.3 练习3

有三个老人,年龄分别为70  80  60  求出三个老人的最高年龄

public class Demo03Ternary {
    public static void main(String[] args) {
        int old1 = 70;
        int old2 = 80;
        int old3 = 60;

        int temp = old1>old2?old1:old2;

        int max = temp>old3?temp:old3;
        System.out.println("max = " + max);
    }
}