1. 变量
1. 他 她 我 你 某人 佚名 旺财 X-man x = 1
您好！ 它
(变量就是自然语言中的代词)
2. int age = 15;// 00000000 00000000 00000000 00001111
3. Java 中的变量
a Java是强类型语言，
b 变量必须声明，并且初始化以后使用
c 变量必须有明确的类型
d 变量不能重复定义
4. 变量的作用域
a 在声明的地方开始，到块结束为止
b 离开变量的作用域结束，变量将回收。
2. 二进制
1. 计算机内部只有二进制数据！
int i = 15; char c = 'A';
'A'-> 00000000 01000001
15 -> 00000000 00000000 00000000 00001111
115 = 1*100 + 1*10 + 5*1
= 1×10^2 + 1×10^1 + 5×10^0
基数： 10
权: 基数^n
基数:2
权: 128 64 32 16 8 4 2 1
2. 二进制: 1111= 1*2^3+1*2^2+ 1*2^1 + 1*2^0
= 1*8 + 1*4 + 1*2 + 1*1
= 15(10)
8421
1001 = 9
01000001 = 1*64 + 1*1
= 65(10)
128 64 32 16 8 4 2 1
1 1 0 0 0 0 0 0 = 192(10)
3. 十进制: 65 = 6*10 + 5*1
= 6*10^1 + 5*10^0
256 128 64 32 16 8 4 2 1
95(10)= 0 1 0 1 1 1 1 1 (2)
int age = 15;
age = 00000000 00000000 00000000 00001111
int age = 0xf;
4. 16进制
0 1 2 3 4 5 6 7 8 9 a b c d e f
10 11 12 13 14 15
41(16) = 4 * 16 +1 = 65(10)
4 1
0100 0001(2) = 65(10)
* 将16进制作为2进制的简写形式.
4e2d(16)=0100 1110 0010 1101(2)
5. 八进制是二进制的简写,3位对应转换
3.原码、补码、反码
1、原码：一个正数，按照绝对值大小转换成的二进制数；一个负数按照绝对值大小转换成的二进制数，然后最高位补1，称为原码。
比如 00000000 00000000 00000000 00000101 是 5的 原码。
10000000 00000000 00000000 00000101 是 -5的 原码。
备注：
比如byte类型,用2^8来表示无符号整数的话,是0 - 255了；
如果有符号， 最高位表示符号,0为正,1为负,那么,正常的理解就是 -127 至 +127 了.这就是原码了,
值得一提的是,原码的弱点,有2个0,即+0和-0(10000000和00000000)；
还有就是,进行异号相加或同号相减时,比较笨蛋,先要判断2个数的绝对值大小,然后进行加减操作,最后运算结果的符号还要与大的符号相同；
于是,反码产生了。
2、 反码：正数的反码与原码相同，负数的反码为对该数的原码除符号位外各位取反[每一位取反(除符号位)]。
取反操作指：原为1，得0；原为0，得1。(1变0; 0变1)
比如：正数00000000 00000000 00000000 00000101 的反码还是 00000000 00000000 00000000 00000101
负数10000000 00000000 00000000 00000101 的反码则是 11111111 11111111 11111111 11111010。
反码是相互的，所以也可称：10000000 00000000 00000000 00000101 和 11111111 11111111 11111111 11111010互为反码。
备注：还是有+0和-0,没过多久，反码就成为了过滤产物,也就是,后来补码出现了。
3、 补码：正数的补码与原码相同，负数的补码为对该数的原码除符号位外各位取反，然后在最后一位加1.
比如：10000000 00000000 00000000 00000101 的反码是：11111111 11111111 11111111 11111010。
那么，补码为：
11111111 11111111 11111111 11111010 + 1 = 11111111 11111111 11111111 11111011
备注：1、从补码求原码的方法跟原码求补码是一样的 ，也可以通过完全逆运算来做，先减一，再取反。
2、补码却规定0没有正负之分
所以，-5 在计算机中表达为：11111111 11111111 11111111 11111011。转换为十六进制：0xFFFFFFFB。
举例：
a. -2*2 = -4
-2 1110
X 2 0010
---------------
0000
1110
0000
+ 0000
----------------
-4 1100
b. -2 + 3 = 1
-2 1110
+ 3 0011
111
-----------------
1 0001
c. -1+-1 = ?
-1 1111
-1 1111
+ 1111
-------------------
-2 1110
d. 7+1 = ?
7 0111
+ 1 0001
-----------------
-8 1000
e.~3 + 1 = ?
3 0011
~3 1100
+1 0001
------------
-3 1101
-3 1101
~-3 0010
+1 0001
-------------
3 0011
强调：补码运算时负号只与第一位数相连，然后再与后面的数进行运算，如上例-1+-1(1110为-2的补码)，~3 + 1(1101为-3的补码)
总结：
正数的反码和补码都与原码相同。
负数的反码为对该数的原码除符号位外各位取反。
负数的补码为对该数的原码除符号位外各位取反，然后在最后一位加1
源码：优点在于换算简单 缺点在于两个零 加减法需要独立运算
反码：有点在于表示清晰 缺点在于两个零 加减法同样需要独立运算
补码：优点在于一个零 范围大 减法可以转为加法 缺点在于理解困难
4.Java的数据类型
1. Java数据分为基本类型和引用类型. Person someone
2. 基本类型分为八种:
byte short int long float double char boolean
(a) 整数类型 byte short int long
整数都是有符号整数
byte 8bit -128 ~ +127
short 16bit -32768 ~ 32767
int 32bit -2G ~ 2G-1 -2^31 ~ 2^31-1
long 64bit -2^63 ~ 2^63-1
int a = 5;
建议使用int, 很少使用short,使用int要注意取值范围, int 的值不大!
直接量-字面量: 直接给出的常量值如: 1
a. 整数的直接量的类型默认是int类型
b. 以L,l为结尾的字面量是long类型
1024
1024L
c. 可以使用整数直接量给byte,short类型赋值,但是不要超过byte和short的范围.
(b) 浮点数: 就是小数, float, double
34642323.44 = 3.464232344 * 10^7
尾数 指数
10001000.(2)
1.0001000 * 2^111(2)
尾数 指数
float 32位
0 00000111 10001000000000000000000
符号位 指数 尾数
int a = 0x7fffffff;
float f = a;
double
1 符号位
11 指数
52 尾数
a. double 是64位, float 32位
double比float精确
b. 默认的浮点数字面量是: double类型的
字面量后缀: d/D f/F
double d = 1d;//1.0
1 1L 1D 1F
c. 只使用double计算浮点数,float类型基本不用!
浮点数不能精确运算
int:10001000 -> float:1.0001000*2^111
0 00000111 10001000 00000000 0000000
(c) 字符类型:char, 字符类型是一个16位无符号整数!
a. 字符类型的值是对应字符的编码, 是unicode编码. Java支持国际化.
英文部分的值与ascII编码一致.
char是定长编码, 所有的字符都是16位.
'A' -> 0x0041
'中'-> 0x4e2d
在编码中: '0'~'9' , 'a'~'z', 'A'~'Z'都是连续编码的!
'0'=='\u0000' '\u0000'==0
b. 最小值:0, 最大值:65535 = 2^16-1
c. 字符字面量使用单引号为定界符号:'中'
字面量也是整数常量!
特殊字符采用转义字符表示:
如: '\n' '\t' '\\' '\b' '\r'
'\'' '\"' '\u4e2d'
char c = '\\';
(d)布尔类型: boolean
字面量: true false
float f = (float)2.6D;
char c = 65;
5.数据类型转换:
1. 自动类型转换(隐式类型转换)
从小类型到大类型, 自动完成
如: int n = 'A';
long l = 'A';
char-------->int------>long------->float------>double
byte------->short------->int------>long------->float------>double
2. 强制类型转换, 从大类型到小类型需要强制转换
强制类型转换有风险, 会造成精度损失或者溢出
char
byte
long l = 1024L*1024*1024*4;//0x100000000
int i = (int)l;//0
double pi = 3.1415926535897932384626;
float f = (float)pi;
若有不完善的地方请大家多提意见，转发时请注明出处！
