学习目标

• 能够辨识关键字
• 掌握标识符的命名规则和规范
• 理解Java中的数据类型分类
• 能够定义8种基本数据类型的变量
• 理解基本数据类型的自动类型转换
• 理解基本数据类型的强制类型转换
• 了解进制
• 了解ASCII编码表和Unicode编码表
• 理解+符号在字符串中的作用
• 掌握算术运算符
• 掌握赋值运算符
• 掌握比较运算符
• 掌握逻辑运算符
• 掌握三元运算符
• 理解位运算符

1. 关键字（keyword）（掌握）

• 定义：被Java语言赋予了特殊含义，用做专门用途的字符串（单词）
  • HelloWorld案例中，出现的关键字有 public 、class 、 static 、 void 等，这些单词已经被Java定义好
• 特点：全部关键字都是小写字母。
• 关键字比较多，不需要死记硬背，学到哪里记到哪里即可。
• 官方地址： https://docs.oracle.com/javase/tutorial/java/nutsandbolts/_keywords.html

说明：

1. 关键字一共50个，其中const和goto是保留字。
2. true,false,null看起来像关键字，但从技术角度，它们是特殊的布尔值和空值。

2. 标识符( identifier)（掌握）

Java 对各种变量、方法和类等要素命名时使用的字符序列称为标识符。

技巧：凡是自己可以起名字的地方都叫标识符。

标识符的命名规则（必须遵守的硬性规则）：

> 由26个英文字母大小写，0-9 ，_或 $ 组成  
> 数字不可以开头。
> 不可以使用关键字和保留字，但能包含关键字和保留字。
> Java中严格区分大小写，长度无限制。
> 标识符不能包含空格。

练习：miles, Test, a++, --a, 4#R, $4, #44, apps, class, public, int, x, y, radius

标识符的命名规范（建议遵守的软性规则，否则容易被鄙视）:

> 包名：多单词组成时所有字母都小写：xxxyyyzzz。
  例如：java.lang
  
> 类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz
  例如：HelloWorld，String，System等
  
> 变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz
  例如：age,name,bookName,main
  
> 常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ
  例如：MAX_VALUE,PI

注意1：在起名字时，为了提高阅读性，要尽量有意义，“见名知意”。

注意2：java采用unicode字符集，因此标识符也可以使用汉字声明，但是不建议使用。

更多细节详见《代码整洁之道.pdf》《Java开发手册（嵩山版）》

3. 变量（掌握）

3.1 Java中的数据类型

Java的数据类型分为两大类：

• 基本数据类型：包括 整数、浮点数、字符、布尔。
• 引用数据类型：包括数组、 类、接口、枚举、注解。

3.2 初识变量

• 变量的概念：

  • 内存中的一个存储区域

  • 该区域的数据可以在同一类型范围内不断变化

  • 变量是程序中最基本的存储单元。包含变量类型、变量名和存储的值

• 变量的作用：用于在内存中保存数据
• 使用变量注意：
  • Java中每个变量必须先声明，后使用
  • 使用变量名来访问这块区域的数据
  • 变量的作用域：其定义所在的一对{ }内
  • 变量只有在其作用域内才有效
  • 同一个作用域内，不能定义重名的变量

3.2 变量的定义

格式：数据类型  变量名;

//例如：
//存储一个整数类型的年龄
int age; 

//存储一个小数类型的体重
double weight;

//存储一个单字符类型的性别 
char gender;

//存储一个布尔类型的婚姻状态
boolean marry;

//存储一个字符串类型的姓名
String name;

//声明多个同类型的变量
int a,b,c; //表示a,b,c三个变量都是int类型。

注意：变量的数据类型可以是基本数据类型，也可以是引用数据类型。

3.3 变量的赋值

给变量赋值，就是把“值”存到该变量代表的内存空间中。

1、变量赋值的语法格式

变量名 = 值;

• 给变量赋值，变量名必须在=左边，值必须在=右边
• 给变量赋的值类型必须与变量声明的类型一致或兼容

2、可以使用合适类型的常量值给变量赋值

int age = 18;
double weight = 109;
char gender = '女';
boolean beauty = true;
String name = "迪丽热巴";

3、可以使用其他变量或者表达式给变量赋值

int m = 1;
int n = m;
        
int x = 1;
int y = 2;
int z = 2 * x + y;

4、变量可以反复赋值

• 变量的第一次赋值称为初始化；
• 变量的再赋值称为修改变量的值；

//先声明，后初始化
char gender;
gender = '女';

//声明的同时初始化
int age = 18;
System.out.println("age = " + age);///age = 18

//给变量重新赋值，修改gender变量的值
gender = '男';
System.out.println("gender = " + gender);//gender = 男

3.4 小结：变量的三要素

1、数据类型

• 变量的数据类型决定了在内存中开辟多大空间
• 变量的数据类型也决定了该变量可以存什么值

2、变量名

• 见名知意非常重要

3、值

• 基本数据类型的变量：存储数据值

• 引用数据类型的变量：存储地址值，即对象的首地址。例如：String类型的变量存储的是字符串对象的首地址（关于对象后面章节再详细讲解）

4. 基本数据类型介绍

4.1 整数类型：byte、short、int、long

Java各整数类型有固定的表数范围和字段长度，不受具体OS的影响，以保证java程序的可移植性。

Java的整型常量默认为 int 型，声明long型常量须后加‘l’或‘L’

Java程序中变量通常声明为int型，除非不足以表示较大的数，才使用long

4.1.1 计算机存储单位（掌握）

• 字节（Byte）：是计算机用于计量存储容量的基本单位，一个字节等于8 bit。

• 位（bit）：是数据存储的最小单位。二进制数系统中，每个0或1就是一个位，叫做bit（比特），其中8 bit 就称为一个字节(Byte)。

• 转换关系：

  • 8 bit = 1 Byte
  • 1024 Byte = 1 KB
  • 1024 KB = 1 MB
  • 1024 MB = 1 GB
  • 1024 GB = 1 TB

4.2 浮点类型：float、double

• 与整数类型类似，Java 浮点类型也有固定的表数范围和字段长度，不受具体操作系统的影响。

• 浮点型常量有两种表示形式：

  • 十进制数形式：如：5.12 512.0f .512 (必须有小数点）
  • 科学计数法形式:如：5.12e2 512E2 100E-2

• float:单精度，尾数可以精确到7位有效数字。很多情况下，精度很难满足需求。

• double:双精度，精度是float的两倍。通常采用此类型。

• Java 的浮点型常量默认为double型，声明float型常量，须后加‘f’或‘F’。

4.3 字符类型：char

• char 型数据用来表示通常意义上“字符”(2字节)
• Java中的所有字符都使用Unicode编码，故一个字符可以存储一个字母，一个汉字，或其他书面语的一个字符。
• 字符型变量的三种表现形式：
  • 字符常量是用单引号(‘ ’)括起来的单个字符。例如：char c1 = 'a'; char c2 = '中'; char c3 = '9';
  • Java中还允许使用转义字符‘\’来将其后的字符转变为特殊字符型常量。例如：char c3 = ‘\n’; // '\n'表示换行符
  • 直接使用 Unicode 值来表示字符型常量：‘\uXXXX’。其中，XXXX代表一个十六进制整数。如：\u000a 表示 \n。
• char类型是可以进行运算的。因为它都对应有Unicode码。

/*③  可以表示的形式：形式一：一个具体的字符
                  形式二：一个转义字符。比如：\n   \t
                  形式三：使用unicode格式表示。比如:'\u12ab'
                  形式四：可以赋值ascii码表字符对应的整数，代表对应字符'';
*/

//形式一：
    char c = 'A';
    char c = '中‘;
//形式二：
    char c = '\n';
//形式三：
    char c = '\u12ab';
//形式四：
    char c = 97; //c=a

4.3.1 了解：ASCII码

• 在计算机内部，所有数据都使用二进制表示。每一个二进制位（bit）有 0 和 1 两种状态，因此 8 个二进制位就可以组合出 256 种状态，这被称为一个字节（byte）。一个字节一共可以用来表示 256 种不同的状态，每一个状态对应一个符号，就是 256 个符号，从 0000000 到 11111111。

• ASCII码：上个世纪60年代，美国制定了一套字符编码，对英语字符与二进制位之间的关系，做了统一规定。这被称为ASCII码。ASCII码一共规定了128个字符的编码，比如空格“SPACE”是32（二进制00100000），大写的字母A是65（二进制01000001）。这128个符号（包括32个不能打印出来的控制符号），只占用了一个字节的后面7位，最前面的1位统一规定为0。

• 缺点：

  • 不能表示所有字符。
  • 相同的编码表示的字符不一样：比如，130在法语编码中代表了é，在希伯来语编码中却代表了字母Gimel (ג)

4.3.2 了解：Unicode码

• 乱码：世界上存在着多种编码方式，同一个二进制数字可以被解释成不同的符号。因此，要想打开一个文本文件，就必须知道它的编码方式，否则用错误的编码方式解读，就会出现乱码。

• Unicode：一种编码，将世界上所有的符号都纳入其中。每一个符号都给予一个独一无二的编码，使用 Unicode 没有乱码的问题。

• Unicode 的缺点：Unicode 只规定了符号的二进制代码，却没有规定这个二进制代码应该如何存储：无法区别 Unicode 和 ASCII：计算机无法区分三个字节表示一个符号还是分别表示三个符号。另外，我们知道，英文字母只用一个字节表示就够了，如果unicode统一规定，每个符号用三个或四个字节表示，那么每个英文字母前都必然有二到三个字节是0，这对于存储空间来说是极大的浪费。

4.3.3 了解：UTF-8

• UTF-8 是在互联网上使用最广的一种 Unicode 的实现方式。

• UTF-8 是一种变长的编码方式。它可以使用 1-6 个字节表示一个符号，根据不同的符号而变化字节长度。

• UTF-8的编码规则：

  • 对于单字节的UTF-8编码，该字节的最高位为0，其余7位用来对字符进行编码（等同于ASCII码）。
  • 对于多字节的UTF-8编码，如果编码包含 n 个字节，那么第一个字节的前 n 位为1，第一个字节的第 n+1 位为0，该字节的剩余各位用来对字符进行编码。在第一个字节之后的所有的字节，都是最高两位为"10"，其余6位用来对字符进行编码。

4.4 布尔类型：boolean

• boolean 类型用来判断逻辑条件，一般用于程序流程控制：
  • if条件控制语句；
  • while循环控制语句；
  • do-while循环控制语句；
  • for循环控制语句；
• boolean类型数据只允许取值true和false，无null。
  • 不可以使用0或非 0 的整数替代false和true，这点和C语言不同。
  • Java虚拟机中没有任何供boolean值专用的字节码指令，Java语言表达所操作的boolean值，在编译之后都使用java虚拟机中的int数据类型来代替：true用1表示，false用0表示。———《java虚拟机规范 8版》

5. 基本数据类型间运算规则（掌握）

在Java程序中，不同的基本数据类型的值经常需要进行相互转换。Java语言所提供的七种数值类型之间可以相互转换，基本数据类型转换有两种转换方式：自动类型提升和强制类型转换。boolean类型不参与。

5.1 自动类型提升

规则：将取值范围小的类型自动提升为取值范围大的类型 。

基本数据类型的转换规则如图所示：

（1）当把存储范围小的值（常量值、变量的值、表达式计算的结果值）赋值给了存储范围大的变量时。

int i = 'A';//char自动升级为int，其实就是把字符的编码值赋值给i变量了
double d = 10;//int自动升级为double

byte b = 127; //右边的整数常量值必须在-128~127范围内
//byte bigB = 130;//错误，右边的整数常量值超过byte范围
long num = 1234567; //右边的整数常量值如果在int范围呢，编译和运行都可以通过，这里涉及到数据类型转换
long bigNum = 12345678912L;//右边的整数常量值如果超过int范围，必须加L，否则编译不通过

（2）当存储范围小的数据类型与存储范围大的数据类型一起混合运算时，会按照其中最大的类型运算。

int i = 1;
byte b = 1;
double d = 1.0;

double sum = i + b + d;//混合运算，升级为double

（3）当byte,short,char数据类型进行算术运算时，按照int类型处理。

byte b1 = 1;
byte b2 = 2;
byte b3 = b1 + b2;//编译报错，b1 + b2自动升级为int

char c1 = '0';
char c2 = 'A';
int i = c1 + c2;//至少需要使用int类型来接收
System.out.println(c1 + c2);//113 

5.2 强制类型转换

将1.5 赋值到int 类型变量会发生什么？产生编译失败，肯定无法赋值。

int i = 3.14; // 错误

想要赋值成功，只有通过强制类型转换，将double 类型强制转换成int 类型才能赋值。

规则：将取值范围大的类型强制转换成取值范围小的类型。

比较而言，自动类型提升是Java自动执行的，而强制类型转换需要我们自己手动执行。

转换格式：

数据类型 变量名 = （数据类型）被强转数据值;  //()中的数据类型必须<=变量的数据类型，一般都是=

（1）当把存储范围大的值（常量值、变量的值、表达式计算的结果值）赋值给了存储范围小的变量时，需要强制类型转换。这种转换有风险，可能会损失精度或溢出

int i = (int)3.14;//强制类型转换，损失精度

double d = 1.2;
int num = (int)d;//损失精度

int i = 200;
byte b = (byte)i;//溢出

（2）当某个值想要提升数据类型时，也可以使用强制类型转换。这种情况的强制类型转换是没有风险的。

int i = 1;
int j = 2;
double bigger = (double)i/j;

练习：判断是否能通过编译

1）short  s = 5;
   s = s-2;                     //判断：
2） byte b = 3;
    b = b + 4;                  //判断：
    b = (byte)(b+4);            //判断：
3）char c = ‘a’;
   int  i = 5;
   float d = .314F;
   double result = c+i+d;       //判断：
4） byte b = 5;
    short s = 3;
    short t = s + b;            //判断：

5.3 基本数据类型与字符串类型的运算

5.3.1 字符串类型：String

• String不是基本数据类型，属于引用数据类型

• 使用方式与基本数据类型一致。例如：String str = “abcd”;

5.3.2 运算规则

1、任意八种基本数据类型的数据与String类型进行“+”运算时，结果一定是String类型

System.out.println("" + 1 + 2);//12

2、但是String类型不能通过强制类型()转换，转为其他的类型

String str = "123";
int num = (int)str;//错误的
int num = Integer.parseInt(str);//正确的，后面才能讲到，借助包装类的方法才能转

练习：

String str1 = 4;                       //判断对错：
String str2 = 3.5f + “”;               //判断str2对错：
System.out.println(str2);              //输出：
System.out .println(3+4+“Hello!”);     //输出：
System.out.println(“Hello!”+3+4);      //输出：
System.out.println(‘a’+1+“Hello!”);    //输出：
System.out.println(“Hello”+‘a’+1);     //输出：

6. 计算机底层如何存储数据

计算机世界中只有二进制，所以计算机中存储和运算的所有数据都要转为二进制。包括数字、字符、图片、声音、视频等。

世界上有10种人 ，认识和不认识二进制的。

6.1 进制的分类

• 十进制（decimal）

  • 数字组成：0-9
  • 进位规则：满十进一，以0b或0B开头

• 二进制（binary）

  • 数字组成：0-1
  • 进位规则：满二进一

• 八进制（octal）：很少使用

  • 数字组成：0-7
  • 进位规则：满八进一，以数字0开头表示

• 十六进制

  • 数字组成：0-9，a-f
  • 进位规则：满十六进一，以0x或0X开头表示。此处的 a-f 不区分大小写

6.2 进制的换算举例

6.3 二进制如何表示整数？

• 计算机数据的存储使用二进制补码形式存储，并且最高位是符号位，最高位1是负数，最高位0是正数。

• 规 定

  • 正数的补码与反码、原码一样，称为三码合一
  • 负数的补码与反码、原码不一样：
    • 负数的原码：把十进制转为二进制，然后最高位设置为1
    • 负数的反码：在原码的基础上，最高位不变，其余位取反（0变1,1变0）
    • 负数的补码：反码+1

• 例如：byte类型（1个字节，8位）

  25 ==> 原码 0001 1001 ==> 反码 0001 1001 -->补码 0001 1001

  -25 ==>原码 1001 1001 ==> 反码1110 0110 ==>补码 1110 0111

整数：
正数：25   00000000 00000000 000000000 00011001（原码）
正数：25   00000000 00000000 000000000 00011001（反码）
正数：25   00000000 00000000 000000000 00011001（补码）

负数：-25  10000000 00000000 000000000 00011001（原码）
负数：-25  11111111 11111111 111111111 11100110（反码）
负数：-25  11111111 11111111 111111111 11100111（补码）

为什么要使用原码、反码、补码表示形式呢？

计算机辨别“符号位”显然会让计算机的基础电路设计变得十分复杂! 于是人们想出了将符号位也参与运算的方法. 我们知道, 根据运算法则减去一个正数等于加上一个负数, 即: 1-1 = 1 + (-1) = 0 , 所以机器可以只有加法而没有减法, 这样计算机运算的设计就更简单了。

一个字节可以存储的整数范围是多少？

1个字节：8位

0000 0001  ~  0111 111 ==> 1~127

1000 0001 ~ 1111 1111 ==> -127 ~ -1

0000 0000 ==>0

1000 0000 ==> -128（特殊规定）=-127-1

6.4 十进制转二进制

十进制转二进制：除2取余的逆

6.5 二进制与八进制、十六进制间的转换

二进制转八进制

二进制转十六进制

八进制、十六进制转二进制

6.6 进制间的转换

练习：

1.将以下十进制数转换为十六进制和二进制
123  256  87  62


2.将以下十六进制数转换为十进制和二进制
0x123   0x25F  0x38  0x62

7. 运算符（Operator）（掌握）

运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。

运算符的分类：

• 按照功能分为：算术运算符、赋值运算符、比较(或关系)运算符、逻辑运算、位运算符、条件(或三元)运算符、Lambda运算符

• 按照操作数个数分为：一元运算符（单目运算符）、二元运算符（双目运算符）、三元运算符 （三目运算符）

7.1 算术运算符

举例1：加减乘除模

public class OperatorDemo01 {
    public static void main(String[] args) {
        int a = 3;
        int b = 4;
        
        System.out.println(a + b);// 7
        System.out.println(a - b);// -1
        System.out.println(a * b);// 12
        System.out.println(a / b);// 计算机结果是0，为什么不是0.75呢？
        System.out.println(a % b);// 3
        
        System.out.println(5%2);//1
        System.out.println(5%-2);//1
        System.out.println(-5%2);//-1
        System.out.println(-5%-2);//-1      
        //商*除数 + 余数 = 被除数
        //5%-2  ==>商是-2，余数时1    (-2)*(-2)+1 = 5
        //-5%2  ==>商是-2，余数是-1   (-2)*2+(-1) = -4-1=-5
    }
}

举例2：“+”号的两种用法

• 第一种：对于+两边都是数值的话，+就是加法的意思
• 第二种：对于+两边至少有一边是字符串的话，+就是拼接的意思

public class OperatorDemo02 {
    public static void main(String[] args) {
        // 字符串类型的变量基本使用
        // 数据类型 变量名称 = 数据值;
        String str1 = "Hello";
        System.out.println(str1); // Hello
        
        System.out.println("Hello" + "World"); // HelloWorld
        
        String str2 = "Java";
        // String + int --> String
        System.out.println(str2 + 520); // Java520
        // String + int + int
        // String       + int
        // String
        System.out.println(str2 + 5 + 20); // Java520
    }
}

举例3：自加自减运算

理解：++ 运算，变量自己的值加1。反之，-- 运算，变量自己的值减少1，用法与++ 一致。

1、单独使用

• 变量在单独运算的时候，变量前++和变量后++，变量的是一样的；
• 变量前++ ：例如 ++a 。
• 变量后++ ：例如 a++ 。

public class OperatorDemo3 {
    public static void main(String[] args) {
        // 定义一个int类型的变量a
        int a = 3;
        //++a;
        a++;
        // 无论是变量前++还是变量后++，结果都是4
        System.out.println(a);
    }
}

2、复合使用

• 和其他变量放在一起使用或者和输出语句放在一起使用，前++和后++就产生了不同。

• 变量前++ ：变量先自身加1，然后再取值。
• 变量后++ ：变量先取值，然后再自身加1。

public class OperatorDemo03 {
    public static void main(String[] args) {
        // 其他变量放在一起使用
        int x = 3;
        //int y = ++x; // y的值是4，x的值是4，
        int y = x++; // y的值是3，x的值是4
        
        System.out.println(x);
        System.out.println(y);
        System.out.println("==========");
        
        // 和输出语句一起
        int z = 5;
        //System.out.println(++z);// 输出结果是6，z的值也是6
        System.out.println(z++);// 输出结果是5，z的值是6
        System.out.println(z);
        
        int a = 1;
        a = a++;//(1)先取a的值“1”放操作数栈(2)a再自增,a=2(3)再把操作数栈中的"1"赋值给a,a=1

        int i = 1;
        int j = i++ + ++i * i++;
        /*
        从左往右加载
        (1)先算i++
        ①取i的值“1”放操作数栈
        ②i再自增 i=2
        （2）再算++i
        ①i先自增 i=3
        ②再取i的值“3”放操作数栈
        （3）再算i++
        ①取i的值“3”放操作数栈
        ②i再自增 i=4
        （4）先算乘法
        用操作数栈中3 * 3 = 9，并把9压会操作数栈
        （5）再算求和
        用操作数栈中的 1 + 9 = 10
        （6）最后算赋值
        j = 10
        */
    } 
}

• 小结：
  • ++在前，先自加，后使用；
  • ++在后，先使用，后自加。

练习1：算术运算符：自加、自减

public class SignTest{
        public static void main(String[] args){
                int i1 = 10;
                int i2 = 20;
                int i = i1++; //i=10 i1=11
                System.out.print(“i=”+i);
                System.out.println(“i1=”+i1);
                i = ++i1; //i=12 i1=12
                System.out.print(“i=”+i);
                System.out.println(“i1=”+i1);
                i = i2--; //i=12 i2=11
                System.out.print(“i=”+i);
                System.out.println(“i2=”+i2);
                i = --i2; //i=10 i2=10
                System.out.print(“i=”+i);
                System.out.println(“i2=”+i2);
         }
}

练习2：

随意给出一个整数，打印显示它的个位数，十位数，百位数的值。
格式如下：
数字xxx的情况如下：
个位数：
十位数：
百位数：

例如：
数字153的情况如下：
个位数：3
十位数：5
百位数：1

int num = 153;
int ge = num % 10; //个位
int shi = num / 10 % 10; //十位
int bai  = num / 100 % 10; //百位 

7.2 赋值运算符

• 符号：=

  • 当“=”两侧数据类型不一致时，可以使用自动类型转换或使用强制类型转换原则进行处理。
  • 支持连续赋值。

• 扩展赋值运算符： +=, -=, *=, /=, %=

public class OperatorDemo04 {
    public static void main(String[] args) {
        int a = 3;
        int b = 4;
        int c = a + b;        
        
        b += a;// 相当于 b = b + a ; 
        System.out.println(a); // 3
        System.out.println(b); // 7 
        System.out.println(c); //7
        
        short s = 3;
        // s = s + 4; 代码编译报错，因为将int类型的结果赋值给short类型的变量s时，可能损失精度
        s += 4; // 代码没有报错
        //因为在得到int类型的结果后，JVM自动完成一步强制类型转换，将int类型强转成short
        System.out.println(s);
        
        int j = 1;
        j += ++j * j++;//相当于  j = j + (++j * j++);
        System.out.println(j);//5
        
        int m = 1;
        m <<= 2; //m=m << 2 = m * 2 * 2;
        System.out.println(m); //4
    }
}

思考1：

short s = 3; 
s = s+2;  ①
s += 2;    ②
①和②有什么区别？ 
① 会编译报错，因为s（short）和 2（int）相加，自动提升为int，再赋值给short，会编译报错
需要这样修改：s = (short)(s + 2);
② 编译通过，s+=2 中间不会提升类型

思考2：

int i = 1;
i *= 0.1;
System.out.println(i);//0 因为是 *= i的类型不会提升为double 所以值为 0
i++;
System.out.println(i);//1 

思考3：

int m = 2;
int n = 3;
n *= m++;   //n = n * m (m++) => n=2*3 m=3
System.out.println("m=" + m);  //3
System.out.println("n=" + n); //6

思考4：

int n = 10; 
n += (n++) + (++n); //n= 10 + 10(n=11)+12(n=12) = 32
System.out.println(n); //32

7.3 关系运算符/比较运算符

• 比较运算符的结果都是boolean型，也就是要么是true，要么是false。
• 比较运算符“==”不能误写成“=” 。

思考：

boolean b1 = false;
//区分好==和=的区别。
if(b1=true) //由于 b1=true 是直接赋值成了true，
       System.out.println("结果为真"); 
else
      System.out.println("结果为假");

//结果为真

7.4 逻辑运算符

• 逻辑运算符，是用来连接两个布尔类型值的运算符（!除外），运算结果也是boolean值true或者false

• 逻辑运算符用于连接布尔型表达式，在Java中不可以写成3<x<6，应该写成x>3 & x<6 。

• “&（与）”和“&&（短路与）”的区别：

  • 单&时，左边无论真假，右边都进行运算；
  • 双&时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算。

• “|（或）”和“||（短路或）”的区别同理，||表示：当左边为真，右边不参与运算。

• 异或( ^ )与或( | )的不同之处是：当左右都为true时，结果为false。
  • 理解：异或，追求的是“异”!

public class OperatorDemo06 {
    public static void main(String[] args) {
        int a = 3;
        int b = 4;
        int c = 5;

        // & 与，且；有false则false  
        System.out.println((a > b) & (a > c));  //false & false =false
        System.out.println((a > b) & (a < c)); //false & false = false
        System.out.println((a < b) & (a > c)); //true & false  = false
        System.out.println((a < b) & (a < c)); //true & true = true
        System.out.println("===============");
        // | 或；有true则true
        System.out.println((a > b) | (a > c));  //false | false = false
        System.out.println((a > b) | (a < c));  //false | true = true
        System.out.println((a < b) | (a > c)); //true | false  = true;
        System.out.println((a < b) | (a < c)); //true | true = true
        System.out.println("===============");
        // ^ 异或；相同为false，不同为true
        System.out.println((a > b) ^ (a > c)); //false | false = false
        System.out.println((a > b) ^ (a < c));  //false | true = true
        System.out.println((a < b) ^ (a > c)); //true | false = true
        System.out.println((a < b) ^ (a < c)); //true | true = true
        System.out.println("===============");
        // ! 非；非false则true，非true则false
        System.out.println(!false); //true
        System.out.println(!true); //false
        
        //&和&&的区别
        System.out.println((a > b) & (a++ > c));  //false & 3>5(false) =false
        System.out.println("a = " + a); //a=4
        System.out.println((a > b) && (a++ > c));  //false && (前为false，后不执行)
        System.out.println("a = " + a); //a=4
        System.out.println((a == b) && (a++ > c));  //true && 4>5 false =false
        System.out.println("a = " + a); //5
        
        //|和||的区别
        System.out.println((a > b) | (a++ > c)); //true | 5 > 5(false) =true
        System.out.println("a = " + a); //a=6
        System.out.println((a > b) || (a++ > c)); // true || (之后不执行)=true
        System.out.println("a = " + a); //a=6
        System.out.println((a == b) || (a++ > c)); //false || 6 > 5(true) = true
        System.out.println("a = " + a); //7
    }
}

练习：请写出每题的输出结果

int x = 1;
int y=1;

if(x++==2 & ++y==2){ //1(x=2)==2 false & 2(y=2)==2 true = false
    x =7;
}
System.out.println("x="+x+",y="+y);  //x=2 y=2

int x = 1,y = 1;

if(x++==2 && ++y==2){ //1(x=2)==2 false && = false
    x =7;
}
System.out.println("x="+x+",y="+y); //x=2 y=1

int x = 1,y = 1;

if(x++==1 | ++y==1){ //1(x=2)==1 true | 2(y=2)==1 =true
    x =7;
}
System.out.println("x="+x+",y="+y); //x=7 y=2

int x = 1,y = 1;

if(x++==1 || ++y==1){ //1(x=2)==1 true || =true
    x =7;
}
System.out.println("x="+x+",y="+y); //x=7 y=2

练习：程序输出

1．  class  Test  {
2.        public static void main (String []  args)  {
3．           boolean x=true;
4．           boolean y=false;
5．           short z=42;
6．      //if(y == true)
7.           if( (z++==42) && (y=true) )z++; //42(z=43)==42 true && true = true z=44 
8.           if((x=false) || (++z==45))  z++; //false || 45(z=45)==45 true = true  z=46
9．
10.          System. out.println("z="+z); //46
11.            }
12.   }

//结果为：
//z= 46

7.5 位运算符

• 位运算符的运算过程都是基于二进制的补码运算

（1）左移：<<

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

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

            byte,short,char在计算时按照int类型处理

3<<4  类似于  3*2的4次= 3*16 = 48

-3<<4  类似于  -3*2的4次= -3*16 = -48

（2）右移：>>

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

69>>4  类似于  69/2的4次 = 69/16 =4

-69>>4  类似于  -69/2的4次 = -69/16 = -5

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

运算规则：往右移动后，左边空出来的位直接补0，不看符号位

正数：和右移一样

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

69>>>4  类似于  69/2的4次 = 69/16 =4

-69>>>4   结果：268435451

（4）按位与：&

运算规则：对应位都是1才为1

    1 & 1 结果为1

    1 & 0 结果为0

    0 & 1 结果为0

    0 & 0 结果为0

9&7 = 1

-9&7 = 7

（5）按位或：|

运算规则：对应位只要有1即为1

    1 | 1 结果为1

    1 | 0 结果为1

    0 | 1 结果为1

    0 & 0 结果为0

9|7  结果： 15

-9|7 结果： -9

（6）按位异或：^

运算规则：对应位一个为1一个为0，才为1

    1 ^ 1 结果为0

    1 ^ 0 结果为1

    0 ^ 1 结果为1

    0 ^ 0 结果为0

9^7  结果为14

-9^7 结果为-16

（7）按位取反：~

运算规则：~0就是1

           ~1就是0

~9  结果：-10

~-9  结果：8

练习1：

练习2：体会 m = k ^ n = (m ^ n) ^ n

练习3：交换两个变量值的操作

    //方式1：定义一个临时变量 。更具有通用性
    int temp = a;
    a = b;
    b = temp;
    
    //方式2：数学运算的方式
    //a = a + b;//30 = 10 + 20
    //b = a - b;// 10 = 30 - 20
    //a = a - b;//20 = 30 - 10

    //方式3： 体会 a ^ b ^ a  ---> b r
    a = a ^ b;
    b = a ^ b;
    a = a ^ b;
    System.out.println("a = " + a + ", b = " + b);

练习4：二进制转十六进制

    int num = 60;
    int j1 = num & 15;
    String s1 = (j1 > 9)? (char)(j1 - 10 + 'A') + "" : j1 + "";//取出了最低的4位对应的字符
    
    int j2 = (num >> 4) & 15;
    String s2 = (j2 > 9)? (char)(j2 - 10 + 'A') + "" : j2 + "";//取出了次最低的4位对应的字符
    
    System.out.println(s2 + s1);

7.6 条件运算符

• 条件运算符格式：

(条件表达式)? 表达式1:表达式2

• 说明：
  ① 条件表达式必须是boolean类型的
  ② 表达1和表达式2数据类型一致即可
  ③ 结论：凡是使用条件运算符的结构 都可以改写成if-else结构;反之，不成立。
  如果遇到既可以使用条件运算符，又可以使用if-else结构的场景，建议使用条件运算符。因为效率稍高

public static void main(String[] args) {
    int i = (1==2 ? 100 : 200);
    System.out.println(i);//200
    int j = (3<=4 ? 500 : 600);
    System.out.println(j);//500
}

public class ConditionOperator{
    public static void main(String[] args){
        //判断两个变量a,b谁大，把大的变量赋值给max
        int a = 2;
        int b = 2;
        int max = a >= b ? a : b;
        //如果a>=b成立，就取a的值赋给max，否则取b的值赋给max
        System.out.println(max);
        
        boolean marry = false;
        System.out.println(marry ? "已婚" : "未婚"  );
    }
}

• 表达式1和表达式2为同种类型
• 条件运算符的嵌套使用。不建议使用，因为可读性差

练习：

获取两个数中的较大数

获取三个数中的较大数

//方式1：
        int max1 = (n1 > n2)? n1 : n2;
        int max2 = (max1 > n3)? max1 : n3;
        System.out.println("最大值为：" + max2);

        //方式2：条件运算符的嵌套使用。不建议使用，因为可读性差
        int max3 = (((n1 > n2)? n1 : n2) > n3)? ((n1 > n2)? n1 : n2) : n3;
        System.out.println("最大值为：" + max3);

7.7 运算符优先级

提示说明：

（1）表达式不要太复杂

（2）先算的使用()