传智播客_2015年Java基础视频-深入浅出精华版 笔记（2015年9月14日23:11:11）

9.原码反码补码
原码：
正数的原码最高位是0；
负数的原码最高位是1；
其他的是数值位。
符号位 数值位
+7 0 0000111
-7 1 0000111

反码：
正数的反码与原码相同。
负数的反码与原码是符号不变，数值位取反(0变1,1变0）

+7 0 0000111
-7 1 1111000

补码：
正数的补码与原码相同
负数的补码是在反码的基础上加1.

+7 0 0000111
-7 1 1111001

有符号数据表示法的练习
A:已知某数X的原码为10110100B，试求X的补码和反码。

符号位 数值位

原码: 1 0110100

反码： 1 1001011

补码： 1 1001100

B:已知某数X的补码11101110B，试求其原码。

符号位 数值位

补码： 1 1101110

反码： 1 1101101

原码： 1 0010010

10.数据类型：Java是一种强类型的语言，针对每一种数据都定义了明确的数据类型。

数据类型分类：
A:基本数据类型
B:引用数据类型(类,接口,数值)

基本数据类型:4类8种
A:整数 占用字节数
byte 1
short 2
int 4
long 8

B:浮点数
float 4
double 8

C:字符
char 2
D:布尔
boolean 1

注意：
整数默认是int类型
浮点数默认是double类型。

长整型后缀用L或者l标记。建议使用L。
例如
在Java中，
long j = 10000000000;
System.out.println(j);
编译时会报错 错误: 过大的整数: 10000000000，因为整数(这里是10000000000)默认是int类型
解决办法 long j = 10000000000L;

单精度浮点数用F或者f标记。建议使用F。
例如
在Java中，
float f = 12.345;
System.out.println(f);
编译时会报错 错误: 不兼容的类型: 从double转换到float可能会有损失
解决办法 float f = 12.345F;

11.数据类型转换
默认转换(从小到大的转换)
A:byte,short,char—int—long—float—double
B:byte,short,char相互之间不转换，他们参与运算首先转换为int类型
举例
=================================================================
byte a = 3;

int b = 4;

byte c = a + b;//有问题

int d = a + b;//没有问题
=================================================================
上述 byte c = a + b;//有问题
如何解决？用强制类型转换

12.强制转换：
从大的数据类型到小的数据类型。

格式：
目标数据类型 变量 = (目标数据类型) (被转换的数据);

注意：
不要随意的去使用强制转换，因为它隐含了精度损失问题。
那么，
//用强制类型转换改进
byte c = (byte) (a + b);
System.out.println(c);

13.思考题：看看下面两个定义有没有区别呢?
float f1 = (float)12.345;
float f2 = 12.345f;

f1其实是通过一个double类型转换过来的。
而f2本身就是一个float类型。(建议用f2的写法)

14.面试题
A面试题：
byte b1=3,b2=4,b;
b=b1+b2;
b=3+4;
哪句是编译失败的呢？为什么呢？

答：b = b1 + b2;是有问题的。
因为变量相加，会首先看类型问题，最终把结果赋值的也会考虑类型问题。
常量相加，首先做加法，然后看结果是否在赋值的数据类型范围内，如果不是，才报错。

也就是说。b = b1 + b2; -----这个是类型提升，所有有问题。b1 + b2首先整体提升为int类型(byte,short,char相互之间不转换，他们参与运算首先转换为int类型)，int类型的（b1+b2）赋值给byte类型的b，所以有损失精度的错误。

b = 3 + 4; //常量，先把结果计算出来，然后看是否在byte的范围内，如果在就不报错。也就是说，编译器把3+4看做一个常量而不是变量的加法运算。所以不报错

15.强制转换数据溢出后的结果怎么算(一个实例)

byte b = 130;有没有问题?如果我想让赋值正确，可以怎么做?结果是多少呢?

//我们可以使用强制类型转换
byte b = (byte) 130;

//结果是多少呢?
System.out.println(b);

分析过程：
我们要想知道结果是什么，就应该知道是如何进行计算的。
而我们又知道计算机中数据的运算都是补码进行的。
而要得到补码，首先要计算出数据的二进制。

A:获取130这个数据的二进制。
00000000 00000000 00000000 10000010
这是130的原码，也是反码，还是补码。
B:做截取操作，截成byte类型的了。
10000010
这个结果是补码。
C:已知补码求原码。(注意不要漏掉这一步，因为内存中操作的是补码，而我们看到的是补码，所以还要转换成原码)
符号位 数值位
补码： 1 0000010

反码： 1 0000001

原码： 1 1111110
16.
//直接输出一个字符
System.out.println(‘a‘); //输出a
//输出一个字符和一个整数做加法
System.out.println(‘a‘+1); //输出98

ASCII码表。
记住三个值：
‘a‘ 97
‘A‘ 65
‘0‘ 48注意

17.字符串参与运算
System.out.println("hello"+‘a‘+1); //输出helloa1，hello优先与‘a’结合
System.out.println(‘a‘+1+"hello"); //输出98hello，‘a’优先与1结合，形成98再与hello结合

System.out.println("5+5="+5+5); //输出5+5=55，字符串与数字5先结合
System.out.println(5+5+"=5+5"); //输出10=5+5，5+5优先形成10，再与字符串结合

5.一个面试题
面试题：
short s=1;s = s+1;

short s=1;s+=1;
上面两个代码有没有问题，如果有，那里有问题。
class OperatorTest {
public static void main(String[] args) {
//short s = 1;
//s = s + 1;
//System.out.println(s);

short s = 1;
s += 1; //好像是 s = s + 1;
System.out.println(s);
}
}

为什么第二个木有问题呢?
扩展的赋值运算符其实隐含了一个强制类型转换。

s += 1;
不是等价于 s = s + 1;
而是等价于 s = (s的数据类型)(s + 1);
(个人理解)也就是说，s = s + 1中的s + 1包含了加法运算，short类型出现了提升（提升为int类型）
而s+=1本身隐含了强制的类型转换

6.逻辑运算符：
&,|,^,!
&&,||

特点：
逻辑运算符一般用于连接boolean类型的表达式或者值。

表达式：就是用运算符把常量或者变量连接起来的符合java语法的式子。
算术表达式：a + b
比较表达式：a == b

结论：
&逻辑与:有false则false。
|逻辑或:有true则true。
^逻辑异或:相同为false，不同为true。
举例：情侣关系。男男,男女,女男,女女
!逻辑非:非false则true，非true则false。
特点：偶数个不改变本身。

例如
int a = 3;
int b = 4;
int c = 5;

//&逻辑与
System.out.println((a > b) & (a > c)); //false & false = false
System.out.println((a > b) & (a < c)); //false & true = false
System.out.println((a < b) & (a > c)); //true & false = false
System.out.println((a < b) & (a < c)); //true & true = true

7.Java中&&与&

&&和&的区别? 同理||和|的区别?
A:最终结果一样。
B:&&具有短路效果。左边是false，右边不执行。

开发中常用的逻辑运算符：
&&,||,!
示例

//boolean b1 = ((x++ == 3) & (y++ == 4));
//boolean b1 = ((x++ == 3) && (y++ == 4));
//boolean b1 = ((++x == 3) & (y++ == 4));
boolean b1 = ((++x == 3) && (y++ == 4));
System.out.println("x:"+x);
System.out.println("y:"+y);
System.out.println(b1);