CoreJava学习第二课
一：编程习惯（很重要！！！提高程序可读性）
1.注释(描述代码的文字)
1.单行注释 //注释内容
2.多行注释 /* 多行注释，
可以跨越多行 注意：多行注释不能嵌套
*/
3.文档注释 /**
配合javadoc工具使用
*/2.缩进
· 同级代码左对齐，每行一句代码
· 每进入一个代码块{}，缩进一次3.标识符（程序员为程序组件起的名字）
语法:
1) 字母 数字 下划线 货币符号 数字不能开头
2) 不能使用关键字和保留字 (goto const) true false null
3) 大小写敏感
4) 没有长度限制4.命名规范：【很重要】
① 望文生义
② 大小写
包名：全小写 com.cps.corejava.day01
类名：所有单词首字母大写 HelloWorld
变量名|函数名： 首单词小写，其它单词首字母大写 printStar
常量名：所有单词大写，单词之间使用_连接 HELLO_WORLD二：进制转换
1.字节（1 Byte = 8 bit）
计算机把8个二进制位固定在一起，称为一个字节
1Byte最多存8位：_ _ _ _ _ _ _ _ 128+64+32+16+8+4+2+1=255
2Byte最多存16位：_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 65535
2.进制转换
十进制转二进制
90
45 0
22 1
11 0
5 1
2 1
1 0
0 1 结果是： 1011010
小数是乘以2运算：从上往下
0.2
0.4 0
0.8 0
1.6 1
1.2 1
0.4 0
0.8 0
1.6 1
1.2 1 90.2 = 1011010.001100110011001100110011...
因为0.2转二进制后会出现无限循环，所以十进制90.2转二进制，最后可能会出现精度丢失 三：变量
int a = 10;
int是变量类型，a是变量名称，10就是变量1.变量
基本的数据存储单元
2.变量类型
决定计算机要提供多大的内存空间（byte short int ...提供的最大存储量不一样）
3.强类型和弱类型约束
为了提高计算机内存的使用效率，引入强类型约束：
强类型：变量的类型和数据的类型必须一致
弱类型：定义变量不用指定变量类型，例如：JavaScript中 的var
注：
var a = 10;在JDK10之后就是对的，因为编译器会自动推断a的字面值是10,10是int类型。
如果再写a = 2.5;就会报错，因已经认定a是int类型四：数据类型(2种：基本数据类型，对象数据类型)
一.1 基本（原始/简单）数据类型（1-4，共8种）
1.byte 1B -128 - 127
1B 8 位 _ _ _ _ _ _ _ _ 第一个是符号位，0正1负
2.short 2B -32768 - 32767
3.int 4B -2147483648 - 2147483647
4.long 8B -9223372036854775808 - 9223372036854775807 字面值加l或L一.2 基本数据类型（5-8，共8种）
| float | double （默认） | |
|---|---|---|
| 精度 | 单精度浮点数 | 双精度浮点数 |
| 分配的内存空间 | 4B | 8B |
| 字面值 | 加 F 或 f | 加 D 或 d 或不加 |
举例：
float f = 1.3;
这样写是错的，因为1.3的字面值是double，编译器会尝试把double降级为float，但是会丢失精度，所以编译器会报错。1.补充：面试题
System.out.println(2.0-1.1);//结果是0.8999999999999999
因为计算机在存1.1时，需要把1.1转成二进制，此时0.1在转二进制时会丢失精度，所以计算结果就不是0.9 。
System.out.println(2.0F-1.1F);//结果是0.9
此问题涉及到 java虚拟机字节码指令。在java虚拟机底层中，2.0-1.1会被当成double做运算，结果是0.8999999999999999，但结果是一个float类型，此时虚拟机会四舍五入，“凑巧”变成了0.9 。
看下面两个就和上面的不一样了。
System.out.println(2.0-1.2);//0.8
System.out.println(2.0F-1.2F);//0.799999952.补充：浮点数在内存中如何表示？
| float | double （默认） | |
|---|---|---|
| 分配的内存空间 | 4B | 8B |
| 在内存中表示 ？ | 第1个是符号位，指数位8，尾数位23 | 第1个是符号位，指数位11，尾数位52 |
| 字面值 | 加 F 或 f | 加 D 或 d 或不加 |
| 举例表示:1.3*10^10 | 1.3e10F (对) ，1.3eF10(错) | 1.3e10 |
| 精度 | 尾数位加上小数点前的1，共24位 | 尾数位加上小数点前的1，共53位 |
float和double可以用科学计数法表示： a(尾数) *2^ b(指数)
计算机中规定，浮点数在内存中采用科学计数法保存时，小数点前必须是1.例如：
0.1011011 写成 1.011011 指数位写-13.char
char 存字符，分配2B的内存空间，所以表示数据范围:0-65535
1.字面值表示: 1.用单引号引起来'A'
2. 直接写char = 65
3.'\u0041' \u 表示是全球统一的Unicode编码，这是十六进制编码（十六进制编码两位是 1B，char是2B，所以用十六进制编码表示char是4位），所以65用十六进制 表示是0041
2.Unicode编码 全球统一
'A' ---> 65 编码 ； 65 ---> 'A' 解码
3.记住三个
'A' : 65 'a':97 '0':48 转义字符:
\' 输出 '
\" 输出 "
\\ 输出 \
'\n' 换行 ASCII值为10
'\t' Tab键功能 ASCII值为9
使用：
int n = 358;
System.out.println(n%10+"\t"+(n/10%10)+"\t"+(n/100)%10);// 8 5 3
System.out.println(n%10+'\t'+(n/10%10)+'\t'+(n/100)%10);//34 没用双引号时，
4.boolean类型
字面值 : true false
运算符: 布尔表达式
== != > < >= <=
! 逻辑非
短路运算符： && 逻辑与，|| 逻辑或
非短路运算符：& 位运算与，| 位运算或
三元运算符 ?运算符 (布尔表达式)?值1 : 值2 (a%2==0)?"偶数":"奇数"
举例：短路运算符在判断（a>b）&& (c补充一个面试题：
面试题：
boolean类型在内存中的存储空间可以是1位/1B/4B ？
1.在逻辑层面，只需1位即可存储布尔值
2.在内存分配空间时，都是1字节1字节分配的，这样就浪费了7位空间。
3.在虚拟机的字节码指令中，没有专门布尔类型的数据，所以布尔类型会转化成int类型处理，占4B空间。1.计算机用二进制运算（原码，反码，补码）
二进制表示：
5: 00000101
求-5的二进制补码表示：是把5的原码，按位求反再加1
原码 0000 0101
按位求反 1111 1010
加1 1111 1011
-5: 11111011
计算机的CPU只会做加法运算，所以12-5变成12+（-5）
00001100 12
11111011 -5
00000111 7
01111111 表示 127
10000000 表示 -128
11111111 表示 -1
00000000 表示 0 2.字面值(“=”后面的就是字面值)
字面值: int a = 10; int a = 010; int a = 0x10 int a = 0b10
十进制 八进制 十六进制 二进制 (since JDK1.7)
二进制 十进制 十六进制
1010 0101 = 2^7+2^5+2^2+2^0 = 128+32+4+1 165 = A5 十六进制中2位表示一个字节
简单一点
1010=A 0101=53.表达式和运算符
表达式: 具有特定的值 如：a+b
运算符: + - * / % = 赋值运算符
+= -= *= /= %= ++ --
11/2 = 5 4/5 = 0 11%2 =1 4%5 = 4
两个变量做运算，储存结果的数据类型由这两个变量的字面值决定。
例如：short和byte做运算，因short和byte没有默认值int大，储存结果的默认是int
long和int做运算，因long比默认值int大，储存结果是long
a+=2;和a=a+2;有区别：
byte a = 1;
a+=2;结果还是byte类型；
a=a+2;因2默认是int类型，所以a+2结果也是int类型，把一个int类型存到byte里会出错。4.位运算
&按位与 |按位或 ^按位异或 ~按位反
<<左移 相当于*2
>> 右移 相当于/2 高位补符号位
>>>无符号右移 高位补0
&按位与（同1才为1）
System.out.println(10&23); //2
/* 00 0 01 0 10 0 11 1
00001010 10
00010111 23
00000010 2
*/
|按位或（有1就为1）
System.out.println(10|23); //31
/*规则： 00 0 01 1 10 1 11 1
00001010 10
00010111 23
00011111 31
*/
^按位异或（01或10为1）
System.out.println(10^23); //29
/*
00001010 00 0 01 1 10 1 11 0
00010111
00011101
*/
~按位反
System.out.println(~10); //-11
/*
00001010
11110101 -11
*/
int a = 10;
<<左移 相当于*2
System.out.println(a<<1);//左移1位，最左边的舍弃，最右边补0
/*
00001010 10
00010100 20
11110110 -10
11101100 -20
*/
>> 右移 相当于/2 高位补符号位
System.out.println(a>>1); //右移1位，最右边的舍弃，高位补符号位
/*
11110110 -10
11111011 -5
*/
>>>无符号右移 高位补0
System.out.println(a>>>1); //2147483643
/*
11111111 11111111 11111111 11110110 -10
01111111 11111111 11111111 11111011 2147483643
*/
5.补充：
①交换a,b的值的三种方式
a b 交换值:
1. c = a a = b b = c
2. a = a^b b = a^b a = a^b
3. a = a+b b = a-b a = a-b
a2=a^b
b2=a2^b=a^b^b = b^b^a = 0^a = a
a3 = a2^b2 = a^b^a = a^a^b = 0^b = b
a2 = a+b
b2 = a2-b=a+b-b=a
a3 = a2-b2 = a+b-a = b
②面试题（异或）
异或用于加密：（最原始的加密方式）
加密：把原文件的所有字节和某一个数（这个数叫做秘钥）做异或，这样原文件的数据就会改变。
解密：再把原文件和秘钥做异或，即可解密。
6.自动类型提升和类型转换
自动类型提升:当小类型变量赋值给大类型变量时，会自动提升类型。
a+b
1. 如果a和b中有double ===> 结果值自动提升为double
2. 否则, 如果a和b中有float ===> float
3. 否则, 如果a和b中有long ===> long
4. 否则 ===> int
强制类型转换/类型间赋值原则: 如果可能改变数据,则需要进行强制类型转换。
整数间强转，会舍去多余的高位字节。
浮点数强转整数，会把小数点后的直接抹去。
public class TestCast{
public static void main(String[] args){
byte b = 1;
short s = 1;
int i = 1;
long l = 1L;
float f = 1.0F;
double d = 1.0;
char c = 'A';
s = b;
i = s;
l = i;
d = f;
i = c;
s = 128; // 00000000 10000000
b = (byte)s ; // 10000000，大类型变量转小类型变量，直接把高位去掉。
System.out.println(b);//-128 类型间赋值可能会改变数据。
f = (float)d ;
i = (int)f;
s = (short)c; // c = 40000
f = l ;
}
}