# 第三章 变量和运算符

# 一、变量

# 1、数据类型

四类八种

# （1）整形的取值范围

byte是一个字节，一共八位，第一个是符号位，所以用于表示数值的只有7位。

所以他的取值范围是：-2^7 ~ 2^7

但是有几个特殊的值我们需要讨论讨论。

在我们写代码的时候一定要考虑边界问题。

0

源码：00000000

反码：00000000

补码：00000000

-0

源码：10000000

反码：11111111

补码：00000000 进位1溢出

128

无法表示

-128

源码：（1）10000000

反码：（1）01111111

补码：（1）11111111 首位溢出 11111111 -128

结论：所以byte的取值范围是 -128 - 127

其他整形以此类推。

# （2）浮点数的取值范围

浮点数的表示，难点，不理解就算了

根据国际标准IEEE 754，任意一个二进制浮点数V可以表示成下面的形式： V = (-1)^s×M×2^E

1. (-1)^s表示符号位，当s=0，V为正数；当s=1，V为负数。
2. M表示有效数字，大于等于1，小于2，但整数部分的1可以省略，也叫尾数。
3. 2^E表示指数位。

符号位

只有两个取值0或者1，0代表正数，1代表负数。

阶码

E为一个无符号整数（unsigned int）,这意味着，如果E为8位，它的取值范围为0_{255；如果E为11位，它的取值范围为0}2047。然而科学计数法中的E是可以出现负数的，所以IEEE 754规定，E的真实值必须再减去一个中间数，对于8位的E，这个中间数是127；对于11位的E，这个中间数是1023。 比如，2^2的E是2，所以保存成float 32位浮点数时，必须保存成2+127=129，即10000001。

尾数

M可以写成1.xxxxxx的形式，其中xxxxxx表示小数部分。IEEE 754规定，在计算机内部保存M时，默认这个数的第一位总是1，因此可以被舍去，只保存后面的xxxxxx部分。比如保存1.0101的时候，只保存0101，等到读取的时候，再把第一位的1加上去。这样做的目的，是节省1位有效数字。以32位浮点数为例，留给M只有23位，将第一位的1舍去以后，等于可以保存24位有效数字。

小例子：-58.2在内存是怎么表示的

1
2

System.out.println(Integer.toBinaryString(Float.floatToIntBits(-58.2F)));
//结果：1 10000100 11010001100110011001101

其实可以写成 -1 * 1.11010001100110011001101 * 2^（132-127） = -1.11010001100110011001101*2^5 = 111010.001100110011001101

是不是相当与小数点向后移动5位啊

-1 * 111010.001100110011001101 大约等于 -58.2

E还需要考虑下面2种情况：

1、E全为0。这时，浮点数的指数E等于1-127（或者1-1023），有效数字M不再加上第一位的1，而是还原为0.xxxxxx的小数。这样做是为了表示±0，以及接近于0的很小的数字。

1
2
3
4

System.out.println(Integer.toBinaryString(Float.floatToIntBits(-0F)));
// 结果：1 00000000  00000000000000000000000
System.out.println(Integer.toBinaryString(Float.floatToIntBits(0F)));
// 结果：00000000000000000000000000000000

2、E全为1。这时，如果有效数字M全为0，表示±无穷大（正负取决于符号位s）；如果有效数字M不全为0，表示这个数不是一个数（NaN）。

1
2
3
4
5
6
7
8
9
10

System.out.println(Integer.toBinaryString(Float.floatToIntBits(Float.POSITIVE_INFINITY)));
System.out.println(Integer.toBinaryString(Float.floatToIntBits(Float.NEGATIVE_INFINITY)));
System.out.println(Float.POSITIVE_INFINITY);
System.out.println(Float.NEGATIVE_INFINITY);

// 1111111100000000000000000000000
// 11111111100000000000000000000000
// Infinity
// -Infinity

3、取值范围计算

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

System.out.println(Integer.toBinaryString(Float.floatToIntBits(Float.MAX_VALUE)));
System.out.println(Integer.toBinaryString(Float.floatToIntBits(Float.MIN_VALUE)));
System.out.println(Float.MAX_VALUE);
System.out.println(Float.MIN_VALUE);

// 0 11111110 11111111111111111111111    254-127=127  
// 1.11111111111111111111111 * 2^127，
// 相当于小数点向右移动127位   111111111111111111111111...加102个0  2^127+2^126+...
// 其实大致相当于  2^128 = 3.4028236692093846346337460743177e+38

// 0 00000000 00000000000000000000001
// - 0.00000000000000000000001 * 2^(-126) = -1 * 2^(-126-23) = 1.4012984643248170709237295832899e-45

// 3.4028235E38
// 1.4E-45
// -3.4028235E38 ~ 3.4028235E38

# （3）char的取值范围

简单的聊聊字符编码：

思考：如果用

ASCII

（American Standard Code for Information Interchange，美国信息互换标准代码）

ASCII第一次以规范标准的类型发表是在1967年，最后一次更新则是在1986年，到目前为止共定义了128个字符。ASCII码，用一个字节表示，8位能够表示256个字符，可以用来表示所有的大写和小写字母，数字0到9、标点符号，以及在美式英语中使用的特殊控制字符，足够美国人用的了，事实上他们只用到了128个字符，还有位就空着了。

Unicode

Unicode（统一码、万国码、单一码）是一种在计算机上使用的字符编码。Unicode 是为了解决传统的字符编码方案的局限而产生的，它为每种语言中的每个字符设定了统一并且唯一的二进制编码，规定虽有的字符和符号最少由 16 位来表示（2个字节），即：2 ^16 = 65536（注：此处说的的是最少2个字节，可能更多）。

GB2312

把中国单独拉出来看，MBCS时期，中国于1980年发布了GB2312，就是国标的拼音，这个编码用区位码（94个区，每区94个字符）的方式可以支持7000多个汉字，它所收录的汉字已经覆盖中国大陆99.75%的使用频率，基本可以满足汉字计算机的需要了。

• gb2312 是简体中文的码
• gbk 支持简体中文及繁体中文

UTF-8

UTF-8，是对Unicode编码的压缩和优化，所以UTF-8包含于Unicode，只是他不再使用最少使用2个字节，而是将所有的字符和符号进行分类：ascii码中的内容用1个字节保存、欧洲的字符用2个字节保存，东亚的字符用3个字节保存

查看咱们的字符集

1
2
3
4
5
6

import java.nio.charset.Charset;
public class Demo {
    public static void main(String[] args) {
        System.out.println(Charset.defaultCharset());
    }
}

思考题：

1
2
3

byte num1 = 12;
byte num2 = 13;
byte num3 = num1 + num2;

# 2、定义变量

变量就是一切通过内存分配并赋值的量，分为不可变变量和可变变量

变：能保存一些可变的量，比如年龄，收入等

便： 方便，一次定义，“到处”（作用域内）使用

# （1）过程

• 定义 int i;

• 赋值 i = 5; 定义和赋值可以一起 int i = 5;

• 使用；

# （2）定义变量的规则

1. 变量名字里不能有空格。

2. 避免使用关键字，class public int static

3. 避免使用汉字，不要使用英文和拼音混着写

4. 整体是驼峰命名，首字母小写 lowerCamelCase

5. $和_可以到处使用，但是不建议当做开头

6. 数字不能开头

# 3、基础数据类型的运算

# （1）算术运算符

1

+  -  *  /   %    ++   --  

i++，--i 其实相当于 i = i+1;

1
2
3
4
5

int num1 = 12;
++num1;
System.out.println(num1);

结果是13

1
2
3
4
5

int num1 = 12;
num1++;
System.out.println(num1);

结果是13

1
2
3
4
5
6

int num1 = 12;
int num2 = num1++;
System.out.println(num2);

结果是：12
    先赋值后计算

1
2
3
4
5
6

int num1 = 12;
int num2 = ++num1;
System.out.println(num2);

结果是：13
    先计算后赋值

看看以下的代码：

1
2
3

byte num1 = 12;
long num2 = 13;
long num3 = num1 + num2;

1
2
3
4

int num1 = 12;
int num2 = 13;
int num3 = num1 + num2;
System.out.println(num3);

结论：

算术运算符，int以下的做运算，结果都是int类型，long和其他的类型做运算，结果是long。

++i 和 i++的区别

如果不赋值都是自增1

如果赋值，i++ 是 先把i赋值给其他变量，然后自增， ++i是先赋值再自增。

# （2）逻辑运算符-真值表

逻辑运算的结果是布尔型 boolean 与 或 非

与

或

非

符号表示

& | ！ && ||

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

boolean flag1 = true;
        boolean flag2 = false;

        boolean flag3 = flag1 & flag2;
        boolean flag4 = flag1 | flag2;
        boolean flag5 = !flag1;


        int num1 = 12;
        int num2 = 15;
        boolean flag6 = num1 >= num2;
        boolean flag7 = num1 == num2;


        boolean flag8 = (num1 >= num2) & (num1 == num2);

        System.out.println(flag8);

短路运算符

&& 短路运算符 如果短路运算的结果是false，那么结果直接就是false， 不会继续运算后边的逻辑

|| 短路运算符 如果短路运算的结果是true，那么结果直接就是true， 不会继续运算后边的逻辑

看看以下代码：

1
2
3

byte num1 = 12;
byte num2 = 13;
byte num3 = num1 & num2;

1
2
3

byte num1 = 12;
long num2 = 13;
long num3 = num1 & num2;

1
2
3

char c1 = '1';
char c2 = '2';
char c3 = c1 & c1;

1
2

System.out.println('a');
System.out.println('a'+'b');

亦或

^ 相同为零 不同为1

# （3）赋值运算符号

1

+= -= *= /= =

i += 5 相当与 i = i + 5;

# （4）三目运算符

条件 ？ 结果1 ： 结果2；

条件的结果一定是boolean ，只能是true或者false；

条件是可以复杂的

1
2
3
4

boolean condition1 = 5 > 3;
boolean condition2 = 5 > 3;
boolean condition3 = 5 > 3;
int num = (condition1 && (condition2 || condition3)) ? 1 : 2;

# （6）位移运算符

# 4、数据类型的转型

int类型的变量转long，怎么转，自动转。

1
2
3

int num1 = 152;
long num2 = num1;
System.out.println(num2);

long类型的变量转int，怎么转，强转。

1
2
3

long num1 = 2345645645645464564L;
int num2 = (int)num1;
System.out.println(num2);

float类型转long

1
2
3

float num1 = 234545654654654564564564.4F;
long num2 = (long)num1;
System.out.println(num2);

long类型转float

1
2
3

long num1 = 2345645645645464564L;
float num2 = num1;
System.out.println(num2);

结论：

任何有精度缺失（有可能让两个数变成完全不一样的两个数）的转型都需要强转，jvm不给你负责。

取值范围大的转取值范围小的自动转，反之需要强转。