java 计算代码行数据类型_Java学习5：数据类型（下）与运算符

数据类型(下)

char x = 97;这个java语句是允许的，并且输出的结果是'a'.

由此可知，

当一个整数赋值给char类型变量的时候，会自动转换成char字符型，最终的结果是一个字符。

当一个整数没有超出char的趣致范围的时候，这个整数可以直接赋值给char类型的变量。

二进制原码、反码、补码

计算机在任何情况下都稚嫩识别二进制。

计算机在底层存储数据的时候，一律存储的是“二进制补码形式”

计算机采用二进制补码形式存储数据的原因是：补码形式效率最高。

对于一个正整数来说，二进制原码、反码、补码是同一个，完全相同。

int i = 1;

对应的二进制原码：00000000 00000000 00000000 00000001

对应的二进制反码：00000000 00000000 00000000 00000001

对应的二进制补码：00000000 00000000 00000000 00000001

对于一个负数来说

byte i = -1;

对应的二进制原码：10000001

对应的二进制反码(符号位不变，其它位取反)：11111110

对应的二进制补码(反码+1)：11111111

分析：byte b = (byte) 150;这个b输出多少？

int类型的4个字节的150的二进制码是：00000000 00000000 00000000 10010110

强转为1个字节的byte类型，最终在计算机中的二进制码是：10010110

注存储意：计算机永远存储的都是二进制的补码形式。

也就是说10010110，这是一个二进制补码形式，可以用逆推导的方式推算出这个二进制补码对应的原码是什么。

10010110--->二进制补码形式

10010101--->二进制反码形式

11101010--->二进制原码形式

11101010化成十进制就是 -(64+32+8+2)= -106

所以，输出结果应该是-106

byte short char 混合运算

public class Int{

public static void main(String[] args){

char c1 = 'a';

byte b = 1;

//注意：这里的“+”是负责求和的。

System.out.println(c1 + b);//输出的是98

}

}

结论：byte、short、char做混合运算的时候，各自先转换成int再做运算。

short k = 98;这是没有任何问题的。但是，short s = c1 + b;是不能通过编译的。编译器不知道这个加法运算最后的结果是多少，只知道是int类型。如果想要改正，可以用short s = (short)(c1 + b);

多种数据类型的混合运算

多种数据类型做混合运算的时候，最终的结果类型是“最大容量”对应的类型。

char+short+byte混合运算的时候除外，会各自先转换成int类型在做运算。

int类型和int类型最终的结果还是int类型。

java中规定，int类型和int类型最终的结果还是int类型。

在java中计算结果不一定是精确的。

int temp1 = 10/3;//这里“/”是除号，运行结果最终取整

System.out.printfln(temp1);//输出结果是3

int temp2 1/2;

System.out.printfln(temp2);//输出结果是0

浮点型数据

浮点型包括：float(4个字节)、double(8个字节)

float是单精度，double是双精度，double更精确。

但是需要注意的是，如果用在银行方面或者说使用在财务方面，double也是远远不够的。在java中提供了一种精度更高的类习惯，这种类型专门使用在财务软件方面：java.math.BigDecimal(属于引用数据类型)

float和double存储数据的时候都是存储的近似值。

因为现实世界中有这种无限循环的数据，数据实际上是无限循环的，但是计算机内存有限，用一个有限的资源表示无限的数据，只能存储近似值。

注意：任意一个浮点型都比整数型空间大。float容量>long容量。

java中规定，任何一个浮点型数据默认被当作double来处理。如果想让这个浮点型字面量被当作float类型来处理，那么请在字面量后面添加F或f。

float f = 3.14;这个是不能编译通过的，要想编译通过，可以float f = 3.14f;，也可以float f = 3.14F;，也可以float f = (float)3.14;

布尔型数据

在java语言中boolean类型只有两个值，没有其他值：true和false。

不像c或者c++，c语言中1和0也可以表示布尔类型。

boolean类型在实际开发中，使用在逻辑判断当中，通常放到条件位置上(充当条件)

基本数据类型转换规则

第一条：八种基本数据类型中，出boolan类型不能转换，剩下的其中类型之间都可以进行转换。

第二条：如果整数型字面量没有超出byte，short，char的取值范围，可以直接将其赋值给byte，short，char类型的变量。

第三条：小容量向大容量转换成为自动类型转换，容量从小到大的排序为：

byte < short(char) < int < long < float < double，其中short和char都占用两个租户额，但是char可以表示更大的正整数。

第四条：大容量转换成小容量，成为强制类型转换，编写时必须添加“强制类型转换符”，但运行时可能出现精度损失，谨慎使用。

第五条：byte，short，char类型混合运算时，先各自转换成 int 类型再做运算。

第六条：多种数据类型混合运算，各自先转换成容量最大的那一种再做运算。

所有得笔试题都超不过以上的规则。

练习

public class Test{

public static void main(String[] args){

//编译报错，类型不兼容，int转byte可能会丢失

byte b1 = 1000;

//可以

byte b2 = 20

//可以;

short s = 1000;

//可以

int c = 1000;

//可以

long d = c;

//编译错误，类型不兼容，long转int可能会丢失

int e = d;

//可以

int f = 10 / 3;

//可以

long g = 10;

//编译错误，类型不兼容，long转int可能会丢失

int h = g / 3;

//可以

long m = g/3;

//编译错误，类型不兼容，int转byte可能会丢失

byte x = (byte)g / 3;

//可以

short y = (short)(g/3);

//可以

short i = 10;

//可以

byte j = 5;

//编译报错，short和byte做运算最终结果是int类型，int类型转short，可能会丢失

short k = i + j;

//可以

int n = i + j;

//可以

char cc = 'a';

System.out.println("cc = " + cc);//输出cc = 'a'

System.out.println((byte)cc);//输出97

//可以

int o = cc + 100;

System.out println(o);//输出197

}

}

运算符

拿不准运算符优先级 就加个括号。

运算符概述

运算符.png

算数运算符

求和

相减

乘积

/ 商

% 求余数(求模)

++ 自加1

-- 自减1

public class SuanShu{

public static void main(String[] args){

int a = 10;

int b = 3;

System.out.println(a + b);//加运算，输出的是13

System.out.println(a - b);//减运算，输出的是7

System.out.println(a * b);//乘运算，输出的是30

System.out.println(a / b);//除运算，输出的是3

System.out.println(a % b);//取余数运算，输出的是1

}

}

对于++运算符来说，可以出现在变量前，也可以出现在变量后。不管出现在变量前还是变量后，总之++执行结束之后一定会自加1。

int i = 10;

i++;

System.out.println(i);//输出11

int k = 10;

++k;

System.out.println(k);//输出11

当++出现在变量后，会先做赋值运算，再自加1。

当++出现在变量前，会先进行自加1运算，然后在赋值。

//++出现在变量后

int m = 10;

int n = m++;

System.out.println(n);//输出10

System.out.println(m);//输出11

//++出现在变量前

int x = 100;

int y = ++x;

System.out.println(y);//输出101

System.out.println(x);//输出101

练习

int c = 90;

System.out.println(c++);//这里有一个隐形的赋值运算。//输出90

//将上一行代码拆开

//int temp1 = c++;

//System.out.println(temp1);

System.out.println(c);//输出91

int d = 80;

System.out.println(++d);//输出81

//将上一行代码拆开

//int temp2 = ++d；

//System.out.println(temp2);

System.out.println(d);//输出81

-- 运算符也是同样的道理。

关系运算符

=

<

<=

==

!=

一定要记住一个规则：所有的关系运算符的运行结果都是布尔类型，不是true就是false，不可能是其它值。

在Java语言中：

= ：赋值运算符

== ：关系运算符，判断是否相等。

注意：关系运算符中如果有两个符号的话，两个符号之间不能有空格。

public class GuanXi{

public static void main(String[] args){

int a = 10;

int b = 3;

System.out.println(a > b);//输出的是true

System.out.println(a >=b);//输出的是true

System.out.println(a < b);//输出的是false

System.out.println(a <= b);//输出的是false

System.out.println(a == b);//输出的是false

System.out.println(a != b);//输出的是true

}

}

逻辑运算符

& 逻辑与 理解成 并且

| 逻辑或 理解成 或者

！ 逻辑非 理解成 不是 (取反)

&& 短路与

|| 短路或

注意：逻辑运算符两边要求都是布尔类型，并且最终的运算结果也是布尔类型。

对于逻辑与运算符来说，只要有一边是flase，结果就是false。只有两边同时为true，结果才为true。

对于逻辑或运算符来说，只要有一边是true，结果就是true。

对于逻辑非运算符来说，感叹号后面是flase，那就是true，感叹号后面是true，那就是flase。取反。

“短路与 &&” 和“逻辑与 &” 的运算结果没有任何区别，完全相同。只不过“短路与&&”会发生短路现象。

接下来需要理解以下什么是短路现象，什么时候会发生“短路”。

使用短路与的时候，当左边表达式为false的时候，右边的表达式不执行。这种现象叫短路。

从效率方面来说，短路与比逻辑与的效率更高一些。

int x = 10;

int y = 11;

//逻辑与，在两边结果都是true的情况下，结果才是true。

//左边的 x>y 表达式结果已经是false了，其实整个表达式的结果已经确定是false了，按道理来说，右边的表达式不应该执行。

System.out.println( x > y & x > y++);

//通过测试，x > y++ 这个表达式执行了。

System.out.println( y);//输出结果为12

//测试短路与

int m = 10;

int n = 11;

//使用短路与的时候，当左边表达式为false的时候，右边的表达式不执行。

//这种现象叫短路。

System.out.println( m > n && m > n++);

System.out.println(n);//输出结果为11

//

对于短路或运算符来说，当左边的表达式结果为true的时候，右边的表达式不需要执行，此时会短路。

赋值运算符

赋值运算符包括“基本运算符”和“扩展赋值运算符”

基本赋值运算符：=

扩展赋值运算符：

+=

-=

*=

/=

%=

注意：扩展赋值运算符在编写的时候，两个符号之间不能有空格。

赋值运算符的特点是，右边的表达式先执行，将执行完的这个结果通过等号赋值给左边的变量。

以 += 运算符作为代表，学习扩展赋值运算符。其他的扩展赋值运算符，原理相似。

int k = 10;

k += 20;//k变量追加20 k +=20 类似于 k = k + 20

System.out.println(k);//输出结果为30

i += 10 和 i = i + 10 不完全一样，只能说相似，其实本质上并不是完全相同。

byte x = 100;

System.out.println(x);

//错误：不兼容的类型，从int转换到byte可能会有损失。

//x = x + 1;//编译器检测到x + 1是int类型，int类型不可以直接赋值给byte类型的变量x。

//使用扩展赋值运算符可以。

x += 1；//x在定义的时候就是byte类型，那么x变量的类型永远都是byte。不会变，不管后面是多大的数字。

//其实x += 1 等同于：x = (byte)(x + 1)

结论：x += 1 和 x = x + 1不一样。

很重要的语法机制：使用扩展赋值运算符的时候，永远都不会改变运算结果类型。

条件运算符(三目运算符)

语法格式：布尔表达式 ? 表达式1 : 表达式2

执行原理：布尔表达式的结果为true时，表达式1的执行结果作为整个表达式的结果。布尔表达式的结果为false时，表达式2的执行结果作为整个表达式的结果。

定义变量的时候类型不能随意编写。

如果最终的计算结果是字符型，变量需要使用char类型定义。

表达式1和表达式2的数据类型一定是一样的。编译器会检查数据类型。

字符串连接运算符“+”

运算符在java语言中有两个作用。

作用1：求和

作用2：字符串拼接

当 + 运算符两边都是数字类型的时候，求和。

当 + 运算符两边的任意一边是字符串类型，那么这个 + 会进行字符串拼接操作。

一定要记住：字符串拼接完之后的结果还是一个字符串。

注意：当一个表达式当中有多个加号的时候，遵循自左向右的顺序依次执行。除非额外添加了小括号，小括号的优先级高。

口诀：加一对双引号，双引号之间加两个加号，两个加号之间放上变量名

练习题

第一题：判断以下程序的输出结果

int x = 10;

int a = x + x++; //++在变量后，先赋值再自加1

System.out.println("a = " + a);//10+10=20 输出结果为a = 20

System.out.println("x = " + x);//x++已经执行 输出结果为x = 11

int b = x + ++x; //++在变量前，先自加1再赋值

System.out.println("b = " + b);//11+12=23 输出结果为b = 23

System.out.println("x = " + x);//++x已经执行 输出结果为x = 12

int c = x + x--; //--在变量后，先赋值再自减1

System.out.println("c = " + c);//12+12=24 输出结果为c = 24

System.out.println("x = " + x);//x--已经执行 输出结果为x = 11

int d = x + --x; //--在变量前，先自减1再赋值

System.out.println("d = " + d);//11+10=21 输出结果为d = 21

System.out.println("x = " + x);//--x已经执行 输出结果为x = 10

第二题：判断以下程序的输出结果

int a = 15;

int b = 2;

double c = 2;

System.out.println(a + "/" + b + "=" +(a/b));输出结果为15/2=7

System.out.println(a + "%" + b + "=" +(a%b));输出结果是15%2=1

System.out.println(a + "/" + c + "=" +(a/c));输出结果是15/2=7.5

System.out.println(a + "%" + b + "=" +(a%c));输出结果是15%2=1.0

第三题：判断以下程序的输出结果

boolean x,y,z;

int a = 15;

int b = 2;

x = a > b;//true

y = a < b;//false

z = a != b;//true

System.out.println("x =" + x);输出结果为x =true

System.out.println("y =" + y);输出结果为x =false

System.out.println("z =" + z);输出结果为x =true

第四题：判断以下程序的输出结果

int x;

double y;

x = (int)22.5 + (int)34.7;

y = (double)x;

System.out.println("x =" + x);输出结果为x = 56

System.out.println("y =" + y);输出结果为y = 56.0

第五题：判断以下程序的输出结果

int i = 5;

int j = 5;

int m = 5;

int n = 5;

i++; //这行代码执行结束之后 i = 6

j = j + 1; //这行代码执行结束之后 j = 6

m--; //这行代码执行结束之后 m = 4

n = n - 1; //这行代码执行结束之后 n = 4

System.out.println(i);//输出结果为6

System.out.println(i++);//++出现在变量后面，先赋值再自加1 输出结果为6(这行代码结束之后 i 就是7了)

System.out.println(++i);//++出现再变量前 先自加1再赋值 输出结果为8

System.out.println(i--);//--出现在变量后 先赋值再自减1 输出结果为8(这行代码结束之后 i 就是7了)

System.out.println();//换行

System.out.println(j);//输出结果为6

System.out.println(j++);//++出现在变量后面，先赋值再自加1 输出结果为6(这行代码结束之后 j 就是7了)

System.out.println(j--);//--出现在变量后面，先赋值再自减1 输出结果为7(这行代码结束之后 j 就是6了)

System.out.println(--j);//--出现在变量前面，先自减1再赋值 输出结果为5

System.out.println();//换行

System.out.println(m);//输出结果为4

System.out.println(n);//输出结果为4

第六题：判断以下程序的输出结果

int i = 0;

int j = 0;

System.out.println(i);//输出结果为0

System.out.println(j);//输出结果为0

i++;// i = 1

++j;// j = 1

System.out.println(i);//输出结果为1

System.out.println(j);//输出结果为1

System.out.println("----------------");//分隔线

System.out.println(i++);//++出现在变量之后 先赋值再自加1 输出结果为1 此行代码执行完成 i 为2

System.out.println(++j);//++出现在变量之前 先自加1再赋值 输出结果为2

System.out.println("----------------");//分隔线

System.out.println(i);输出结果为2

System.out.println(j);输出结果为2

}