Java学习5：数据类型（下）与运算符

作者: 苦难_69e0 | 来源:发表于2020-09-01 22:11 被阅读0次

数据类型（下）

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
    }