【JavaSE笔记】第二章进制数据类型和运算符

水深无声 2022-01-29 13:51 617阅读 0赞

# 第二章 进制数据类型和运算符 #

### 文章目录 ###

*  第二章 进制数据类型和运算符
 *  第一节 进制及其转换
 *   *  1.1 进制类型
     *  1.2 计算机为什么使用二进制而不使用十进制
     *  1.3 二进制和十进制相互转换
     *  1.4 各进制数之间的关系
 *  第二节 常见存储单位
 *   *  2.1 存储单位介绍
     *   *  位 bit
         *  字节 byte
         *  字符 ：16bit
         *  计算机存储单位转换
         *  符号位
         *  字节 byte表示的数的范围
         *  字符 表示的数的范围
 *  第三节 标识符、关键字、字符编码
 *   *  3.1 标识符
     *  3.2 关键字/保留字
     *  3.3 字符编码
 *  第四节 数据类型、常量和变量
 *   *  4.1 数据类型
     *   *  整型数据类型
         *  浮点型数据类型
         *  字符数据类型（2个字节）
         *  布尔数据类型（一位，不是一个字节）
     *  4.2 常量和变量
     *   *  变量
         *  常量
     *  4.3 final常量和Scanner输入
 *  第五节 基本数据类型的类型转换
 *   *  5.1 类型转换的介绍
     *  5.2 自动类型转换
     *  5.3 强制类型转换（显式）
 *  第六节 运算符
 *   *  6.1 算术运算符
     *  6.2 赋值运算符
     *  6.4 逻辑运算符
     *  6.5 位运算符
     *  6.6 条件运算符
     *  6.7 运算符的优先级别
 *  本章总结

# 第一节 进制及其转换 #

## 1.1 进制类型 ##

十进制：人类使用

二进制：计算机使用

八进制和十六进制：为了更好的表示二进制（缩短二进制长度）

## 1.2 计算机为什么使用二进制而不使用十进制 ##

物理上容易实现，可靠性强；

运算简单

便于进行逻辑运算。

![在这里插入图片描述][20190522103115170.png]

## 1.3 二进制和十进制相互转换 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI2ODM4MzE1_size_16_color_FFFFFF_t_70]

## 1.4 各进制数之间的关系 ##

**![加粗样式][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI2ODM4MzE1_size_16_color_FFFFFF_t_70 1]**

# 第二节 常见存储单位 #

## 2.1 存储单位介绍 ##

### 位 bit ###

最小值 0

最大值 1

表示的数的范围 0-1（2^1-1）

### 字节 byte ###

1byte=8bit

最小值 00000000

最大值 11111111

表示的数的范围 0-255（2^8-1）

### 字符 ：16bit ###

最小值 0000 0000 0000 0000

最大值 1111 1111 1111 1111

表示的数的范围0-65535（2^16-1）

### 计算机存储单位转换 ###

位（bit）：一个数字0或者一个数字1，代表一位。

字节（Byte）：每逢8位是一个字节，这是数据存储的最小单位。

1 Byte = 8 bit

1 KB = 1024 Byte

1 MB = 1024 KB

1 GB = 1024 MB

1 TB = 1024 GB

1 PB = 1024 TB

1 EB = 1024 PB

1 ZB = 1024 EB

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI2ODM4MzE1_size_16_color_FFFFFF_t_70 2]

### 符号位 ###

二进制数如何表示正数和负数呢？

使用最高位作为符号位，0代表整数，1代表负数；  
其余数位用作数值位，代表数值。

### 字节 byte表示的数的范围 ###

无符号数：0-255（28-1） 256个数

有符号数：-128（-27）–127（27-1） 还是256个数

### 字符 表示的数的范围 ###

无符号数 0-65535（216-1） 65536个数

有符号数 -32768（-215）-----32767（215-1） 还是65536个数

![在这里插入图片描述][20190522103226233.png]

# 第三节 标识符、关键字、字符编码 #

## 3.1 标识符 ##

**作用**

常量、变量、方法、类和包等的名称

**命名规则**

*  必须以\*\*字母、\_下划线、美元符$\*\*开头。
 *  其它部分可以是**字母、下划线“\_、美元符“$和数字**的任意组合
 *  **大小写区分**，长度无限制。
 *  不可以是Java的关键字，但可以包含关键字或保留字，如class1等。
 *  标识符不能包含空格。

**注意**

1.  Java不采用通常语言使用的ASCII字符集
2.  Java采用unicode这样的标准的国际字符集。因此，这里的**字母的含义：英文、汉字**等等。(不建议大家使用汉字来定义标识符！)

## 3.2 关键字/保留字 ##

Java关键字是Java语言保留供内部使用的,如class用于定义类。 关键字也可以称为保留字,它们的意思是一样的。

注意：

1.  Java中所有的关键字都是小写的。TRUE,FALSE,NULL
2.  enum是Java

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI2ODM4MzE1_size_16_color_FFFFFF_t_70 3]

## 3.3 字符编码 ##

*  ASCII
 *   *  英文字符集 1个字节
 *  ISO8859-1
 *   *  西欧字符集 1个字节
 *  GB2312
 *   *  大陆使用最早、最广的简体中文字符集 2个字节
 *  GBK
 *   *  GB2312的扩展，可以表示繁体中文 2个字节
 *  GB18030
 *   *  最新GBK的扩展，可以表示汉字、维吾尔文、藏文等中华民族字符 2个字节
 *  BIG5
 *   *  台湾的大五码，表示繁体汉字 2个字节
 *  Unicode ----UTF-8 UTF-16
 *   *  国际通用字符集 2个字节

# 第四节 数据类型、常量和变量 #

## 4.1 数据类型 ##

**Java是一种强类型语言**

*   *   *  常量是有数据类型的
         *  变量都必须声明其数据类型

**八大基本数据类型**

byte 1byte

short 2byte

int 4byte

long 8byte

float 4byte 单精度

double 8byte 双精度

字符类型 unicode字符 不是ascii

char 2byte

布尔类型：表示判断的结果，if,while条件判断的结果

boolean 1bit true false 0，1

> **问题1.float在内存中占据4个字节，int在内存中占据4个字节，从而两种类型表示的范围应该是相同的？**
> 
> 不相同！！！
> 
> 存储的方式，表示的方法是不同的
> 
> int 整数类型 10进制直接转换成二进制，存入即可
> 
> float 浮点类型 4个字节分为前后两部分，前面存储基数，后一部分存放的是指数
> 
> 符号为1位 基数位23 指数位 8
> 
> 前一部分决定精度，后一部分用来决定范围

> **问题2.char和int的区别和联系**
> 
> char类型常量在内存中存储的就是该字符的Unicode编码值（是一个整数），A–65 a—97
> 
>  在一定范围内，字符类型和整型可以通用
> 
>  区别
> 
>  1.分配的空间不同 int 4 char 2
> 
>  2.数值的范围不同 int的范围更大，并且char只有正数没有负数

**注意事项：**

1.  字符串不是基本类型，而是引用类型。
2.  浮点型可能只是一个近似值，并非精确的值。
3.  数据范围与字节数不一定相关，例如float数据范围比long更加广泛，但是float是4字节，long是8字节。
4.  浮点数当中默认类型是double。如果一定要使用float类型，需要加上一个后缀F。  
    如果是整数，默认为int类型，如果一定要使用long类型，需要加上一个后缀L。  
    推荐使用大写字母后缀。

--------------------

### 整型数据类型 ###

**整型常量**

十进制整数，如：99, -500, 0

八进制整数，要求以 0 开头，如：015

十六进制数，要求 0x 或 0X 开头，如：0x15

> 整型常量默认为int型，声明long型常量可以后加‘ l ’或‘ L ‘(建议使用大写，小写容易误认为数字1)，如：
> 
> long a = 55555555; //不出错，在Int表示的范围内(21亿内)。
> 
> long b = 55555555555;//不加l出错，已经超过int表示的范围。

**整型变量**

final int YEAR=365;

![在这里插入图片描述][20190522103400314.png]

### 浮点型数据类型 ###

**浮点类型常量**

十进制数形式，例如:

3.14 314.0 0.314

**科学记数法形式，如**

314e2 314E2 314E-2

double f = 314e2; //314\*10^2–>31400.0

double f2 = 314e-2; //314\*10^(-2)–>3.14

**浮点型变量**

float类型：单精度类型，**尾数可以精确到7位有效数字**，在很多情况下，float类型的精度很难满足需求。

double类型：双精度类型 **精度是float类型的两倍**，绝大部分应用程序都采用double类型。

**注意**

浮点常量默认为double。要变为float，需在后面增加F/f. 如： 3.14F

浮点数存在舍入误差，很多数字不能精确表示。如果需要进行不产生舍入误差的精确数字计算，需要使用BigDecimal类。

![在这里插入图片描述][20190522103423570.png]

--------------------

### 字符数据类型（2个字节） ###

单引号用来表示字符常量。例如‘A’是一个字符，它与“A”是不同的，“A”表示含有一个字符的字符串。

char 类型用来表示在Unicode编码表中的字符。

Unicode编码被设计用来处理各种语言的所有文字，它占2个字节，可允许有65536个字符；ASCII码占1个字节，可允许有128个字符（最高位是0），是Unicode编码表中前128个字符。

Java 语言中还允许使用转义字符 ‘\\’ 来将其后的字符转变为其它的含义，

char c2 = ‘\\n’; //代表换行符

char类型在内存中存储的是该字符的Unicode编码值，所以char类型可以当做int类型来处理

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI2ODM4MzE1_size_16_color_FFFFFF_t_70 4]

### 布尔数据类型（一位，不是一个字节） ###

boolean类型有两个值，true和false

boolean 类型用来**判断逻辑条件，一般用于程序流程控制**

实践：

请不要这样写：if ( is == true && done == false ) ，只有新手才那么写。对于任何程序员 if ( whether && !done ) 都不难理解吧。所以去掉所有的==false 和 ==true。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI2ODM4MzE1_size_16_color_FFFFFF_t_70 5]

public  class TestDataType{ 
    	public static void main(String [] args){ 
    		//整数类型
    		byte b = 64;
    		//byte b = 640; //超过了byte类型变量的存储范围 -128---127
    		System.out.println("b="+b);
    		int i = 640;
    		System.out.println("i="+i);
    		long l = 6401234576L; //如果整数常量值超过了int的范围，要添加l或者L后缀，建议大写
    		System.out.println("l="+l);
    		
    		int i1 = 0111;  //0 开头 八进制
    		int i2 = 0x111; //0x 0X开头 十六进制 0b二进制
    		int i3 = 111;
    		System.out.println(i1+" "+i2+" "+i3);//73 273 111
    		//浮点类型
    		double pi = 3141.59; //小数写法
    		System.out.println("pi = "+ pi);
    		pi = 3.14159e3;  //科学计数法
    		System.out.println("pi = "+ pi);
    		
    		
    		float f = 3.14F; //默认的浮点常量是double类型 ,如果赋给float变量，需要添加F或者f后缀
    		System.out.println("f="+f); 
    		
    		//字符类型 1个字符（不能是0，2，3，n个字符） 使用单引号括起来 unicode编码
    		//存储一个Unicode字符，不仅仅是一个英文字符;
           	//只能是一个字符；字符常量使用单引号；还可以是转义字符
    		char ch = 'A';//charactor 字符
    		System.out.println("ch="+ch); 
    		ch = '学';
    		System.out.println("ch="+ch); 
    		ch = 'ж';
    		System.out.println("ch="+ch); 
    		
    		ch = '\n'; //转义字符 转义字符也是一个（控制）字符
    		System.out.println("ch="+ch); 
    		ch = '\"'; // \ ' "的转义表示
    		System.out.println("ch="+ch); 
    		
    		ch = 97; //A:65 a:97 char变量在内存中存储的就是字符的编码值
    		System.out.println("ch="+ch); 
    		
    		System.out.println("MaxInteger: "+Integer.MAX_VALUE);
    		System.out.println("MinInteger: "+Integer.MIN_VALUE);
    		System.out.println("MaxCharacter: "+(int)Character.MAX_VALUE);
    		System.out.println("MinCharacter: "+(int)Character.MIN_VALUE);
    		
    		//布尔类型:
    		boolean flag = false;
    		System.out.println("flag = " + flag );
    		flag = true;
    		System.out.println("flag = " + flag );
    	
    	}
    
    }

## 4.2 常量和变量 ##

**常量变量定义**

*  在程序中存在大量的数据来代表程序的状态，其中有些数据在程序的运行过程中值会发生改变，有些数据在程序运行过程中值不能发生改变，这些数据在程序中分别被叫做**变量**和**常量**。
 *  年龄和体重会变化，使用变量存储 年龄是整数类型；体重应该是浮点数类型

--------------------

### 变量 ###

**变量：程序运行期间，内容可以发生改变的量。**

创建一个变量并且使用的格式：

数据类型 变量名称; // 创建了一个变量

变量名称 = 数据值; // 赋值，将右边的数据值，赋值交给左边的变量

**一步到位的格式**：数据类型 变量名称 = 数据值; // 在创建一个变量的同时，立刻放入指定的数据值

**变量举例**

*  在2D游戏程序中，需要代表人物的位置，则需要2个变量，一个是x坐标，一个是y坐标，在程序运行过程中，这两个变量的值会发生改变

> **注意:**
> 
> 1.**右侧数值的范围不能超过左侧数据类型的取值范围**
> 
> 2.一个变量定义一次，可以多次使用
> 
> 3.理解=，不是数学中的等于，代表赋值

**使用变量的时候，有一些注意事项：**

1.  如果创建多个变量，那么变量之间的名称不可以重复。
2.  对于float和long类型来说，字母后缀F和L不要丢掉。
3.  如果使用byte或者short类型的变量，那么右侧的数据值不能超过左侧类型的范围。
4.  没有进行赋值的变量，不能直接使用；一定要赋值之后，才能使用。
5.  变量使用不能超过作用域的范围。
    
     *  【作用域】：从定义变量的一行开始，一直到直接所属的大括号结束为止。
6.  可以通过一个语句来创建多个变量，但是一般情况不推荐这么写。

--------------------

### 常量 ###

**常量：在程序运行期间，固定不变的量。**

**常量举例**

*   *  代表常数，便于程序的修改（例如：圆周率的值）
 *   *  增强程序的可读性（例如：常量UP、DOWN、LEFT和RIGHT分辨代表上下左右，其数值分别是1、2、3和4）

**常量的分类：**

1.  字符串常量：凡是用双引号引起来的部分，叫做字符串常量。例如：“abc”、“Hello”、“123”

字符串两个双引号中间的内容可以为空

1.  整数常量：直接写上的数字，没有小数点。例如：100、200、0、-250
2.  浮点数常量：直接写上的数字，有小数点。例如：2.5、-3.14、0.0
3.  字符常量：凡是用单引号引起来的单个字符，就做字符常量。例如：‘A’、‘b’、‘9’、‘中’
    
    **两个单引号中间必须有且仅有一个字符，没有不行。两个单引号中间必须有且仅有一个字符，有两个不行。**
4.  布尔常量：只有量中取值。true、false。
5.  空常量：null。代表没有任何数据。空常量不能直接用来打印输出。

**总结1.认识数据类型常量变量**

数据类型：int double

变量 age weight1 weight2

常量值 10 67.5 76.3

**总结2：在内存中到底发生了什么**

变量其实代表内存中一块空间

变量 房间

变量名 age weight1 房间号

变量类型 int double 房间类型（标准间，三人间 ，总统间）

变量的值 15 70.5 房间中客人

**总结3：变量如何定义**

int age = 15;

变量的类型 变量名 = 变量值;

可以一次定义多个变量

可以定义变量的时候赋值，也可以分开进行

方法中定义的变量没有默认值

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI2ODM4MzE1_size_16_color_FFFFFF_t_70 6]

## 4.3 final常量和Scanner输入 ##

final常量: final double PI=3.14159;

**问题1：如果要修改圆周率的精度，需要修改每个值，繁琐**

解决：定义一个变量pi，存储圆周率的值,减少了修改量

**问题2：因为pi是变量，所以可以中途修改pi的值，导致整个程序中pi的值不一致**

解决：使用final修饰pi finally 最后的 最终的 不能再变化的

**使用final修饰的变量就成了常量**

3.14159 3 字面常量

pi 符号常量

**问题3：存在常量、变量、方法、类等，不能够通过名称直接判断类型**

解决：

**命名规范**

testdatatype
    
     类：  TestDataType  驼峰命名法

变量和方法 testDataType testDataType()

常量 TESTDATATYPE

包 testdatatype

**问题4：半径是死的，要通过键盘输入半径**

解决：Scanner 扫描仪

1.import java.util.Scanner;

2.Scanner input = new Scanner([System.in][]);

3.double r = input.nextDouble();

**总结**

常量：PI 3.14159

字面常量 3.14159 10 67 6.5 true ‘A’

符号常量 final double PI = 3.14159;

# 第五节 基本数据类型的类型转换 #

## 5.1 类型转换的介绍 ##

**1.什么是类型转换**

在(赋值运算或算术)运算时，要求数据类型相同，否则要进行类型转换

**2.类型转换的类型**

基本数据类型的类型转换：

数值类型（int short byte long float double char）和非数值类型(boolean),

类型转换不涉及布尔类型

引用数据类型的类型转换：父类和子类 Person Student Animal Dog 以后再讲

**3.基本数据类型的类型转换的方向**

byte,short,char---->int—>long—>float---->double

**4.算术运算中的转换**

操作数都转换为最大宽度的类型，再运算

3+‘a’+3.14+5L====>3.0+97.0+3.14+5.0

**5.赋值运算中的转换**

左=右 long n = 5+‘a’+123L; 没有发生类型转换

左<右 int n = 5+‘a’+123L; 强制转换 (类型) 做手术

左>右 double n = 5+‘a’+123L; 自动转换

**6.特例**

byte b = 12;

把int赋给byte，short，char，如果数值在byte，short，char范围内，不用强制转换

b=(byte)129;

如果超过了 byte，short，char范围，必须进行强制转换

**7.数字和字符的对照关系表（编码表）：**

**ASCII码表**：American Standard Code for Information Interchange，美国信息交换标准代码。

**Unicode码表**：万国码。也是数字和符号的对照关系，开头0-127部分和ASCII完全一样，但是从128开始包含有更多字符。

**48 - '0’**

**65 - 'A’**

**97 - 'a’**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI2ODM4MzE1_size_16_color_FFFFFF_t_70 7]

## 5.2 自动类型转换 ##

1.  特点：代码不需要进行特殊处理，自动完成。
2.  规则：数据范围从小到大。

> 注意:s += 1;  
> 不是等价于 s = s + 1;  
> 而是等价于 s = (s的数据类型)(s + 1);
> 
> 而s=s+1则会报错，因为右侧数据类型为 byte+int 大于左侧的 byte

public class TestTypeConvert{ 
    	public static void main(String [] args){ 
    		//int n = 10/3;
    		//double n = 10/3;
    		//double n = 10/3.0;
    		//int n = (int)(10/3.0);
    		//System.out.println(n);
    		//算术运算时的类型转换：自动
    		System.out.println(3+'a'+3.14+5L);
    		System.out.println(3+'a'+5L);
    		
    		//赋值运算时
    		long l = 3+'a'+5L; //105 Long; 左 = 右 不需要转换
    		System.out.println(l);
    		double  d = 3+'a'+5L;  // 左double > 右 long 自动类型转换
    		System.out.println(d);
    		int i = (int)(3+'a'+5L+3.14); // 左int < 右 double 强制类型转换 108.14
    		System.out.println(i);
    		
    		//特例
    		byte b = (byte)270;
    		System.out.println(b);
    		b = 20; //-128--127
    		System.out.println(b);
              byte s = 5;
                //s = s+1;
                s+=1;//这个没有问题 内部强制转换
                /* s += 1; 不是等价于 s = s + 1; 而是等价于 s = (s的数据类型)(s + 1); */
                System.out.println(s);
    	}
    
    }

## 5.3 强制类型转换（显式） ##

1.  特点：代码需要进行特殊的格式处理，不能自动完成。
2.  格式：范围小的类型 范围小的变量名 = (范围小的类型) 原本范围大的数据;

**注意事项：**

1.  强制类型转换一般不推荐使用，因为有可能发生精度损失、数据溢出。
2.  byte/short/char这三种类型都可以发生数学运算，例如加法“+”.
3.  byte/short/char这三种类型在运算的时候，都会被首先提升成为int类型，然后再计算。
    
    一旦char类型进行了数学运算，那么字符就会按照一定的规则翻译成为一个数字
4.  boolean类型不能发生数据类型转换
5.  int强制转换为short：注意必须保证逻辑上真实大小本来就没有超过short范围，否则会发生数据溢出
6.  (int)3.99 会显示为3 小数位去掉

# 第六节 运算符 #

## 6.1 算术运算符 ##

/** 技能：算术运算符和赋值运算符 总结1： 如果两个整数运算，结果还是整数 如果两个操作数中有一个是double或者float，则另外一个操作数先转换为double或者float，再进行运算， 结果不是整数类型；（自动类型转换） 总结2：+ 正号 加号 字符串相连 单目双目运算符 结合性 总结3：优先级别 （ + - 加减 ）<(* / %乘 除 取模) < (++ --) <(+ - 正 负) < 小括号 总结4：++ -- n++; ++n;作用是相同的，都相当于n = n +1; 如果n++ ++n是一条单独的语句，两者没有任何区别，都相当于n = n +1; 如果n++ ++n不是一条单独的语句，此时有区别 x++:先运算，后++ ++x; 先++，后运算 注意：变量可以自增自减，常量不可以 int n = 6 + m++; 先运算符再+1 int n = 6 + ++m; 先+1再运算 6++ 变量可以++ -- 常量不可以 */
    public class TestOperator1{ 
    	public static void main(String [] args){ 
    		// / %
    		System.out.println( 12 / 3);  //4
    		System.out.println( 12 / 5);  //2
    		System.out.println( 12 % 5); // 2
    		System.out.println( 12 / 5.0); //2.4
    		System.out.println( 12 % 5.0);//2.0
    		
    		//+
    		System.out.println( +3); //3 正号 单目运算符
    		System.out.println( 6+3); //9 加号 双目运算符
    		System.out.println( 6+3+"ABC"); //9ABC
    		System.out.println( "ABC"+6+3); //ABC63
    		System.out.println( 'a'+5); //not a5 but 102
    		
    		//++
    		int i = 5;
    		System.out.println("i="+i);
    		//i++; // i = i+1 自增1
    		++i; // i = i+1 自增1
    		System.out.println("i="+i);
    		
    		int m = 5;
    		//int n = 6 + m++; //先运算符再加1
    		//int n = 6+m;
    		//m++;
    		//System.out.println(m+" "+n); // 6 11
    		//int n = 6 + ++m;
    		m = m+1;
    		int n = 6+m;
    		
    		System.out.println(m+" "+n); // 6 12
    		
    		//i = (i++)+(i++)+(++i);
    		System.out.println(5 + 6 / 3 % 2 - 4);
    		System.out.println(5 + (6 / 3 % 2) - 4); //提高可读性
    		System.out.println((5 + 6) / 3 % 2 - 4); //改变运算顺序
    		
    		//int n = 5 + 6 / 3 % 2 - 4;
    		
    	}
    }

## 6.2 赋值运算符 ##

/** 技能：赋值运算符 1.= 运算级别最低 结合性：自右向左 是赋值，不是等于 2.扩展的赋值运算符(和算术运算符结合) += -= *= /= %= */
    public class TestOperator2{ 
    	public static void main(String [] args){ 
    		//定义三个分数
    		int score1 = 80;
    		int score2 = 70;
    		int score3 = 95;
    		
    		//求和
    		//int sum = score1+score2+score3;
    		int sum = 0; //方法中定义的变量没有默认值
    		//sum = sum + score1; //80
    		//sum = sum + score2; //150
    		//sum = sum + score3; //245
    		//建议采用此方式
    		//好处1：简单
    		//好处2：编译速度快
    		//可读性差吗？
    		sum+=score1; //sum = sum + score1;
    		sum+=score2;
    		sum+=score3;
    		
    		System.out.println(sum);
    		
    		int m = 6;
    		m*=5+6; // m = m * (5+6) 66 m = m * 5+6 36
    		System.out.println(m);
    		
    	}	
    }

## 6.4 逻辑运算符 ##

/* 技能:逻辑运算符 1.生活案例： 1.用户登录：username正确 并且 password="bjsxt" 2.用户登录失败 username错误 或者 密码错误 除了登录成功之外的 除了（username正确 并且 password="bjsxt"） 3.班级流动红旗颁奖 名次前三名 and 分数大于95分 含义不同 名次前三名 or 分数大于95分 含义 2.逻辑运算符及其运算规则 and 与 & && 双目 or 或 | || 双目 not 非 ! 单目运算符 操作数和结果都是布尔类型 3.逻辑运算符运算规则 4.运算符优先级别： ！> & > | 5.&和&&的联系和区别 |和||的联系和区别 联系： 运算规则相同:两个操作数都是true，结果是true，否则是false 区别 区别1：第一个操作数是false，能决定最终的结果，没有必要计算第二个操作数，此时&和&&有区别 & 还要计算第二个操作数 && 不计算第二个操作数 短路 区别2： & 不仅是逻辑运算符，还是位运算符 && 只是逻辑运算符 开发中常用的是短路逻辑运算符： **/
    public class TestOperator4{ 
    	public static void main(String [] args){ 
    		//& 与 AND :两个操作数都是true，结果是true，否则是false
    		/* System.out.println(true & true); //true System.out.println(true & false); //false System.out.println(false & true); //false System.out.println(false & false); //false */
    		//| 或 OR :两个操作数都是false，结果是false，否则是true
    		//有一个操作数是true，结果是true
    		/* System.out.println(true | true); //true System.out.println(true | false); //true System.out.println(false | true); //true System.out.println(false | false); //false */
    		// ! 非 NOT
    		/* System.out.println(!true); //false System.out.println(!false); //true */
    		//^ 异或 两个操作数相同，结果是false，否则是true
    		/* System.out.println(true ^ true); //false System.out.println(true ^ false); //true System.out.println(false ^ true); //true System.out.println(false ^ false); //false */
    		
    		//优先级别 ！ > & > |
    		//System.out.println(false | true & !false ); 
    		//false | true & true
    		//false | true
    		//true
    		
    		//&和&&的区别和联系
    		//第一个操作数是true，不能确定整个表达式的结果，第二个操作数必须进行运算，此时两者没有区别
    		System.out.println(7<8 & 'A'=='a'); 
    		System.out.println(7<8 && 'A'=='a');
    		//第一个操作数是false，能确定整个表达式的结果，第二个操作数还要进行运算吗？已经没有必要了；
    		//& 会计算第二个表达式的值
    		//&& 短路与 不会计算第二个表达式的值 性能高 在实际开发中使用更多
    		System.out.println(7>8 & 'A'=='a'); 
    		System.out.println(7>8 && 'A'=='a'); 
    		//举例：用户名错误了，就没有必要判断密码了，肯定是登录失败
    		
    		System.out.println(5&6); //&还可以做位运算符，&&不可以
    		//System.out.println(5&&6);
    		
    	}	
    }

## 6.5 位运算符 ##

/** 技能：位运算符1 & | ^ ~ 操作数和结果都是int类型 技能：位运算符2 << 左移运算符:每左移一位，相当于乘以2 >> 右移运算符:每右移一位，相当于除以2.最高位正数补0，负数补1 >>> 无符号右移运算符:不管正数还是负数，最高位一律补0 无符号右移的作用： 无符号右移在数据变换时非常重要。 比如对byte b;做无符号右移，在众多散列、加密、压缩、影音媒体编码、序列化格式都会用到。 如果没有这个无符号右移，就需要用更大的空间去做有符号右移。 了解即可 */
    
    public class TestOperator5{ 
    	public static void main(String [] args){ 
    		//
    		/* System.out.println(5&6);//4 System.out.println(5|6);//7 System.out.println(5^6);//3 System.out.println(~6); //-7 //异或：可以理解为不进位的加法和不进位的减法 //异或的特点：一个数据对另一个数据位异或两次，该数本身不变 System.out.println(5^6^6); */
    		
    		//移位运算符 << 左移 >> 右移 >>> 无符号右移 <<< 没有无符号左移
    		//右移一位，相当于除以2
    		System.out.println(-16>>1); //-8
    		System.out.println(-16>>2); //-4
    		System.out.println(-16>>3); //-2
    		System.out.println(-16>>4); //-1
    		//左移一位，相当于乘以2
    		System.out.println(16<<1); //8
    		System.out.println(16<<2); //4
    		System.out.println(16<<3); //2
    		System.out.println(16<<4); //1
    		
    		System.out.println(7>>1); //8
    		System.out.println(7>>2);
    		System.out.println(7>>3);
    		System.out.println(7>>4);
    		System.out.println(7>>5);
    		
    		System.out.println(-16>>>1); //-8
    		
    		//面试题：请使用最快的方式计算出2*8=？
    		System.out.println(2*8);
    		System.out.println(2<<3);
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI2ODM4MzE1_size_16_color_FFFFFF_t_70 8]

## 6.6 条件运算符 ##

/* 功能：获取两个数中较大的数并输出 技能：条件运算符 1.条件运算符 表达式1？ 表达式2：表达式3 2.运算符规则：表达式1为true，取表达式2的值，否则取表达式3的值 3.唯一的三目运算符 4.优先级别：仅高于赋值运算 5.结合性：自右向左的结合性 6.作用：替代简单的if-else语句 */
    
    public class TestOperator6{ 
    	public static void main(String [] args){ 
    		//定义两个数
    		int num1 = 50;
    		int num2 = 40;
    		
    		//获取两个数中较大的数
    		int max = num1>num2?num1:num2;
    		
    		//输出较大数
    		System.out.println(max);
    		
    		//结合性：自右向左的结合性
    		System.out.println(5>6?5:(7==8?'a':'A'));  
    		//5>6?5:'A'
    		
    	}
    	
    }

## 6.7 运算符的优先级别 ##

*   *   *  不需要去刻意的记优先级关系
         *  赋值<三目<逻辑<关系<算术<单目(单目乘除位关系，逻辑三目(条件)后赋值)
            
             *  **单目算术位关系，逻辑条件后赋值**
 *   *   *  理解运算符的结合性
         *   *  **单目，条件，赋值自右向左**
             *  **其他自左向右**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI2ODM4MzE1_size_16_color_FFFFFF_t_70 9]

# 本章总结 #

1.  **数据类型：基本数据类型和引用数据类型**
    
     *  整型数据类型 byte short int long
     *  浮点型数据类型 float double
     *  字符数据类型 char
     *  布尔数据类型 boolean
2.  **运算符**
    
     *  算术运算符 难点 ++ – 注意+的三个作用
     *  赋值运算符 = += -=… sum+=6---->sum=sum+6关
     *  关系运算符 > < == 关系运算的结果是boolean类型
     *  逻辑运算符 操作数和结果都是boolean型 &和&&的区别和联系（是否短路）
     *  条件运算符 ? : 唯一的三目运算符 int max = num1>num2?num1:num2;
     *  位运算符 了解即可
3.  **运算符的优先级别**
    
    1.  不用刻意背诵，多做练习
    2.  单目>算术>关系>逻辑>条件>赋值
4.  **基本数据类型的类型转换**
    
    1.  自动类型转换 double d=5;
    2.  强制类型转换 int n =(int)3.14;
5.  **其他**
    
     *  字符集 Java采用Unicode字符集 常用字符集都兼容ASCII字符集
     *  final常量 使用final修饰变量，变量变成常量，值不能再被改变
     *  Scanner 可以接收来自键盘的输入

[20190522103115170.png]: /images/20220129/32d488108a5040989cda95cdea6aa4ec.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI2ODM4MzE1_size_16_color_FFFFFF_t_70]: /images/20220129/911b9d1b20904c539a6ed2fb6b4c98c6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI2ODM4MzE1_size_16_color_FFFFFF_t_70 1]: /images/20220129/aeb21b2d5f5c4d2ea67e6f037e0054d4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI2ODM4MzE1_size_16_color_FFFFFF_t_70 2]: /images/20220129/1c7a9d035573419393b322efc8bb797b.png
[20190522103226233.png]: /images/20220129/06a2cecbc3ab4a0d870511c9361b3f49.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI2ODM4MzE1_size_16_color_FFFFFF_t_70 3]: /images/20220129/c79ed723003549ec89d6b70862d0f800.png
[20190522103400314.png]: /images/20220129/a8cedf07985a497085dec29c40405de0.png
[20190522103423570.png]: /images/20220129/141de24068be45f484bf5825e006b8a2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI2ODM4MzE1_size_16_color_FFFFFF_t_70 4]: /images/20220129/6a99be8d778b486a98c5a47a609ab9c2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI2ODM4MzE1_size_16_color_FFFFFF_t_70 5]: /images/20220129/6f9c86c70c1c4a2492896709c81ad1cc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI2ODM4MzE1_size_16_color_FFFFFF_t_70 6]: /images/20220129/cfce1a366b424ef29df626a8ce11d2b4.png
[System.in]: http://System.in
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI2ODM4MzE1_size_16_color_FFFFFF_t_70 7]: /images/20220129/7db239d972124509995ca4ff1ba3aef8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI2ODM4MzE1_size_16_color_FFFFFF_t_70 8]: /images/20220129/b84e3f6fa5cb43ddbbb583c4ad9b32a9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI2ODM4MzE1_size_16_color_FFFFFF_t_70 9]: /images/20220129/cc4636b62b774e7aa5839d57c1c9e108.png