【JavaSE笔记】第二章进制数据类型和运算符
第二章进制数据类型和运算符
第一节进制及其转换
第二节常见存储单位
第三节标识符、关键字、字符编码
第四节数据类型、常量和变量
第五节基本数据类型的类型转换
第六节运算符
本章总结

文章目录

第二章进制数据类型和运算符
第一节进制及其转换

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 计算机为什么使用二进制而不使用十进制

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

运算简单

便于进行逻辑运算。

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

1.4 各进制数之间的关系

第二节常见存储单位

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

符号位

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

使用最高位作为符号位，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个数

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

3.1 标识符

作用

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

命名规则

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

注意

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

3.2 关键字/保留字

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

注意：

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

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只有正数没有负数

注意事项：

字符串不是基本类型，而是引用类型。
浮点型可能只是一个近似值，并非精确的值。
数据范围与字节数不一定相关，例如float数据范围比long更加广泛，但是float是4字节，long是8字节。
浮点数当中默认类型是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;

浮点型数据类型

浮点类型常量

十进制数形式，例如:

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类。

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

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

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

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

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

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

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

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

boolean类型有两个值，true和false

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

实践：

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

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 = '
'; //转义字符  转义字符也是一个（控制）字符
		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.理解=，不是数学中的等于，代表赋值

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

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

常量

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

常量举例

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

常量的分类：

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

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

整数常量：直接写上的数字，没有小数点。例如：100、200、0、-250
浮点数常量：直接写上的数字，有小数点。例如：2.5、-3.14、0.0
字符常量：凡是用单引号引起来的单个字符，就做字符常量。例如：‘A’、‘b’、‘9’、‘中’

两个单引号中间必须有且仅有一个字符，没有不行。两个单引号中间必须有且仅有一个字符，有两个不行。
布尔常量：只有量中取值。true、false。
空常量：null。代表没有任何数据。空常量不能直接用来打印输出。

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

数据类型：int double

变量 age weight1 weight2

常量值 10 67.5 76.3

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

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

变量房间

变量名 age weight1 房间号

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

变量的值 15 70.5 房间中客人

总结3：变量如何定义

int age = 15;

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

可以一次定义多个变量

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

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

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’

5.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 强制类型转换（显式）

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

注意事项：

强制类型转换一般不推荐使用，因为有可能发生精度损失、数据溢出。
byte/short/char这三种类型都可以发生数学运算，例如加法“+”.
byte/short/char这三种类型在运算的时候，都会被首先提升成为int类型，然后再计算。

一旦char类型进行了数学运算，那么字符就会按照一定的规则翻译成为一个数字
boolean类型不能发生数据类型转换
int强制转换为short：注意必须保证逻辑上真实大小本来就没有超过short范围，否则会发生数据溢出
(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);
	}
}

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 运算符的优先级别

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

本章总结

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