Java中数据类型转换、运算符、表达式
1.Java中基本数据类型之间的转换以及注意事项？
1.1.boolean类型：
boolean类型是不参与基本数据类型之间的转换。
1.2.基本数据类型的精度排序【由低到高顺序】
(精度低) byte(字节型) short(短整型) char(字符型) int(整形) long(长整型) float(单浮点型) double(双浮点型) (精度高)
1.3.将数据类型精度低的转换成数据类型精度高的----隐式数据类型转换【自动数据类型转换】
(1)隐式数据类型转换【自动数据类型转换】不需要修改程序，直接赋值即可完成。
(2) 可以直接赋予具体的数据值，也可以将变量赋值。
例如： int--->doubole [隐式数据类型转换【自动数据类型转换】]
public class DataTypeSwitch1{
public static void main(String args[]){
//int--->doubole [隐式数据类型转换【自动数据类型转换】]
//直接赋予具体的数据值
double doublevalue = 100;
System.out.println("doublevalue=="+doublevalue);
//可以将变量赋值
int intnum=300;
double doublevalue2=intnum;
System.out.println("doublevalue2=="+doublevalue2);
}
}
1.4将数据类型精度高的转换成数据类型精度低的--显式数据类型转换【强制数据类型转换】
显式数据类型转换【强制数据类型转换】需要修改程序。
格式：低精度数据类型 变量名称 = (精度低数据类型)精度高的数据值【变量】;
例如：double--->int[显式数据类型转换【强制数据类型转换】]
public class DataTypeSwitch2{
public static void main(String args[]){
//double---int【显示数据类型转换】（强制数据类型转换）高--低
//格式：低精度数据类型 变量名称 =(低精度数据类型)精度高的数据值或者变量
//将小数转换成整数不会“四舍五入”，而是直接舍弃小数部分
int intnum1=(int)12.8;
System.out.println("intnum1=="+intnum1);
double doublevalue1=12.8D;
int value=(int)doublevalue1;
System.out.println("value");
int value ("value=="+value);
}
}
1.5.char与int的转换
char的取值范围就是整数
- char---->int [[隐式数据类型转换【自动数据类型转换】]]
- int---->char[[显式数据类型转换【强制数据类型转换】]]
例如：
public class CharAndInt{
public static void main(String args[]){
//char的取值范围就是整数
//1.char--int[[隐式数据类型转换【自动数据类型转换】]]
char charvalue1='李';
int intvalue1=charvalue1;//隐式数据类型转换
System.out.println("intvalue1=="+intvalue1);
//2.int---char[[显示数据类型转换【强制数据类型转换】]]
int intvalue2=22909;
char charvalue2=(char)intvalue2;
System.out.println("charvalue2=="+charvalue2);
}
}
1.6.int转换成byte
当整数超过取值范围以后，会从最小值向前推进计算。
例如：
public class IntToByte{
public static void main(String args[]){
//当整数超过取值范围以后，会从最小值向前推进计算。
byte bytevalue=(byte)300;
System.out.println("bytevalue=="+bytevalue);
byte value1=127;
byte value2=(byte)(value1+1);
//当整数超过取值范围以后，会从最小值向前推进计算。
System.out.println("value2=="+value2);
}
}
2.赋值运算符与赋值表达式的说明和用法
赋值运算符:”=”
例如:
int num = 100;3.算术运算符与算术表达式的说明和用法
++【自动加1】 --【自动减1】
3.1.当参数算数运算的数据是整数时，运算结果就是整数
例如：
public class SuanShu{
public static void main(String args[]){
//+ - * / %(求余)
int num1=10;
int num2=3;
System.out.println(num1+"+"+num2+"="+(num1+num2));
System.out.println(num1+"-"+num2+"="+(num1-num2));
System.out.println(num1+"*"+num2+"="+(num1*num2));
//当参数算数运算的数据是整数时，运算结果就是整数
System.out.println(num1+"/"+num2+"="+(num1/num2));
System.out.println(num1+"%"+num2+"="+(num1%num2));
}
}
3.2.”++”与”--”的具体用法
“++”--- 自动加1
- 变量++;--【先用后加】
- ++变量;--【先加后用】
“--”--- 自动减1
- 变量--;【先用后减】
- --变量;【先减后用】
例如：
public class SuanShu3{
public static void main(String args[]){
//"++"---自动加1
//1.变量++；--【先用后加】
int num1=10;
System.out.println("变量++=="+(num1++));//10先用
System.out.println("num1=="+(num1));//11后加
//2.++变量；---【先加后用】
int num2=10;
System.out.println("++变量=="+(++num2));//11先加
System.out.println("num2=="+(num2));//11后用
System.out.println("\n");
//"--"---自动减1
//1.变量--；--【先用后减】
int num3=10;
System.out.println("变量--=="+(num3--));//10先用
System.out.println("num3=="+(num3));//9后减
//2.--变量；---【先减后用】
int num4=10;
System.out.println("--变量=="+(--num4));//9先减
System.out.println("num4=="+(num4));//9后用
}
}
3.3.关系运算符与关系表达式的说明和用法
关系运算符: > < >= <= == !=
例如：
public class GuanXi{
public static void main(String args[]){
//关系运算符：> < >= <= == !=
//关系运算符的结果一定是boolean值
int num1=10;
int num2=3;
System.out.println(num1+">"+num2+"="+(num1>num2));
System.out.println(num1+"<"+num2+"="+(num1<num2));
System.out.println(num1+">="+num2+"="+(num1>=num2));
System.out.println(num1+"<="+num2+"="+(num1<=num2));
System.out.println(num1+"=="+num2+"="+(num1==num2));
System.out.println(num1+"!="+num2+"="+(num1!=num2));
}
}
3.4.逻辑运算符与逻辑表达式的说明和用法
逻辑运算符被分成2大类:
1.逻辑运算符 【逻辑或 || 逻辑与 && 逻辑反 !】
例如：
public class LuoJi1{
public static void main(String args[]){
//1.逻辑运算符【逻辑或 || ，逻辑与 && ，逻辑反 ！】
//逻辑运算符的运算值和运算结果一定是boolean值
int num1=10;
int num2=3;
//逻辑或 ||
boolean b1=((num1+num2)>10)||((num1-num2)<3);
System.out.println("b1=="+b1);
//逻辑与 &&
boolean b2=((num1+num2)>10)&&((num1-num2)<3);
System.out.println("b2=="+b2);
//逻辑反 ！
boolean b3=!(((num1+num2)>10)&&((num1-num2)<3));
System.out.println("b3=="+b3);
}
}
（1.1）短路与和短路或
短路或--逻辑或的运算规则
【运算符号左右两边都是false的时候，运算结果就一定是false,如果出现一个true,运算结果就一定是true】
短路或---短路就是运算符号只运算一边
当运算符号左边的结果为true时候，右边不用计算，结果就一定是true.
短路与--逻辑与的运算规则
【运算符号左右两边都是true的时候，运算结果就一定是true,如果出现一个false,运算结果就一定是false】
短路与---短路就是运算符号只运算一边
当运算符号左边的结果为false时候，右边不用计算，结果就一定是false
例如：
public class LuoJi2{
public static void main(String args[]){
//短路或：当运算符号左边的结果位true时，右边不用计算，结果一定
int num1=10;
//System.out.println(num1/0);输出异常
boolean b1=(num1<20)||((num1/0)>10);
System.out.println("b1=="+b1);
System.out.println("\n");
//短路与：当运算符号左边结果为false时，右边不用计算，结果一定为false
int num2=100;
boolean b2 = (num2<20)&&((num2/0)>10);
System.out.println("b2="+b2);
}
}
2. 位运算符的用法
位运算：就是将参与运算的数据转换成2进制【0101001】
10进制与2进制的转换 ： 8421码
1. 原码
原码就是符号位加上真值的绝对值, 即用第一位表示符号, 其余位表示值.
(1)原码 符号位用0表示正数,用1表示负数(用八位表示)
+57原码= 00111001 -57原码=10111001
2. 反码
(1)反码:正数的反码就是原码,负数的反码除符号位不变,其余按位求反
+57反码= 00111001 -57反码=11000110
反码的表示方法是:
(1) 正数的反码是其本身【原码】
(2)负数的反码是在其原码的基础上, 符号位不变，其余各个位取反.
3. 补码
补码的表示方法是:
(1)正数的补码就是其本身【原码】
(2)负数的补码是在其原码的基础上, 符号位不变, 其余各位取反, 最后+1. (即在反码的基础上+1)
整数的2进制就是源码
负数的2进制实质上补码表示:
-3 -- 10000011---11111100---11111101----【负数的原码取反+1】{符号位不变}
-3--3---00000011--11111100---11111101 ---【负数的绝对值的原码的取反+1】
（2.1）.常见的6种位运算符号
相同1为1，不同为0。
例如：3 & -7
0000 0011 3
1111 1001 -7
0000 0001 1
相同位只要一个为1即为1。
例如：3 | -7
0000 0011 3
1111 1001 -7
1111 1011 -5
相同位不同则为1，相同则为0。
例如：3 | -7
0000 0011 3
1111 1001 -7
1111 1010 -6
0和1全部取反
例如：~3
0000 0011 3
取反： 1111 1100 ---求源码 1000 0011 末位加1-- 1000 0100 -4
5.<<左移位 2进制整体向左移动指定的位数
例如 : 3 << 2
0000 0011 3
0000 0110 移动1位
0000 1100 移动2位 --- 12
6.>>右移 2进制整体向右移动指定的位数
例如 : 3 >> 2
0000 0011 3
0000 0001 移动1位
0000 0000 移动2位 --- 0
例如：
public class LuoJi3{
public static void main(String args[]){
//1.& 按位与 相同为1，不同为0。
int num1=3;
int num2=-7;
System.out.println(num1 & num2); // 1
//2.| 按位或 相同位只要一个为1即为1。
System.out.println(num1 | num2); // -5
//3.^ 按位异或 相同位不同则为1，相同则为0。
System.out.println(num1 ^ num2); // -6
//4.~取反 0和1全部取反
System.out.println(~num1); // -4
//5.<<左移位 2进制整体向左移动指定的位数
System.out.println(num1 << 2); //12
//6.>>右移位 2进制整体向右移动指定的位数
System.out.println(num1 >> 2); // 0
System.out.println(2 << 3); //16
}
}
当我们学习完运算符以后，变量和运算符会组成一个运算的表达式，这个运算表达式中的变量的数据类型可能不同，那么这个运算表达式的结果使用什么类型的变量来保存。
这个运算表达式的结果使用参与运算的变量中数据类型精度最高的为标准。
例如：
public class Test{
public static void main(String args[]){
byte by1=120;
short sh1=220;
int int1=1000;
long long1=10000L;
float flo1=12.5f;
double dou1=12.5;
char ch1='A';
float val=by1+sh1+int1+long1+flo1+ch1;
System.out.println("val=="+val);
}
}
例二：
四则混合运算，参数运算的数据类型不是同一类
当参与算术运算的数据类型不是同一类时，它的运算结果的数据类型是精度最高的数据类型
例如：
public class SuanShu2{
public static void main(String args[]){
//四则混合运算，参数运算的数据类型不是同一类
//当参与算数运算的数据类型不是同一类时，
//它的运算结果的数据类型是精度最高的数据类型
byte b=100;
short s=200;
int i=300;
long l=400L;
float f=3.14F;
double d=2.7D;
char c='A';
System.out.println(b+s-i*l/c+f);
}
}
运算符号的优先级
运算符号优先级
运算符 | 综合性 |
[ ] .()(方法调用) | 从左向右 |
! ~ ++ -- +(一元运算符) -(一元运算符) | 从右向左 |
* / % | 从左向右 |
+ - | 从左向右 |
<< >> >>> | 从左向右 |
< <= > >= instanceof | 从左向右 |
== != | 从左向右 |
& | 从左向右 |
^ | 从左向右 |
| | 从左向右 |
&& | 从左向右 |
|| | 从左向右 |
? : | 从右向左 |
= | 从右向左 |
一个特殊的例子：
public class stlye
{
public static void main(String[] args)
{
int a=10,b=6;
System.out.println("改变之前的数：a="+a+",b="+b);
a-=b++;
System.out.println("改变之后的数：a="+a+",b="+b);
}
}运算结果为：
改变之前的数：a=10,b=6
改变之后的数：a=4,b=7
因为b++运算中先执行++，再返回后置++运算表达式(b++)的返回值（6）给-=运算符。
在这个程序中a-=b++等于a=a-b++=10-6,所以a=4。
注：来自百度百科。
综合实例：
1.最有效率的方法算出2乘以8等於几?
2<<3; 表示2向左移3位 （计算机直接运行二进制效率比十进制高）
2.下面代码运行后，e变量的值是多少？
int a =1,b=2; int e = ++a + ++a + b++ + b++;
2+3+2+3=10 e==10；
3.System.out.println("10/3=="+(10/3));
显示结果为 3 没有定义数据类型的整数默认为int型
4.short s1 = 1; s1 = s1 + 1;有错吗?
有错
因为没有定义数据类型的整数数据默认为int型
int型要转换为short型只能显式转换（强制数据类型转换）
short s1=1;
s1 = (short)(s1+1);
