类型转换、运算符

最新推荐文章于 2022-12-09 10:59:07 发布

紫罗兰与海棠

最新推荐文章于 2022-12-09 10:59:07 发布

阅读量182

点赞数 1

分类专栏： JAVA 文章标签： java

本文链接：https://blog.csdn.net/weixin_52467834/article/details/118165091

版权

JAVA 专栏收录该内容

24 篇文章 0 订阅

订阅专栏

本文详细介绍了Java中的数据类型转换，包括默认转换和强制转换，并给出了实例演示可能遇到的问题。此外，还讲解了算术运算符、赋值运算符、比较运算符、逻辑运算符以及三元运算符的用法，包括它们的优先级和在实际编程中的应用。文章还讨论了字符和字符串在运算中的特殊行为。

摘要由CSDN通过智能技术生成

一，类型转换
-一般来说，我们在运算的时候要求参与运算的数据的数据类型要一致。
-boolean类型比较特殊不能转换成其他类型

1，默认转换(从小到大的转换)
-byte,short,char他们三个之间不转换,在参与运算的时候都会先转换成int类型
-byte,short,char–int–long–float–double
class Demo1{
public static void main(String[] args){
//直接输出+运算
System.out.println(3+8);

	//变量之间做运算
	int a = 4;
	int b = 5;
	int c = a+b;
	System.out.println(c);
	
	//byte x = 4;
	//byte y = 5;
	//错误: 不兼容的类型: 从int转换到byte可能会有损失
	//byte z = x+y;
	//System.out.println(z);
	
	//byte x = 4;
	//short y = 5;
	//错误: 不兼容的类型: 从int转换到short可能会有损失
	//short z = x+y;
	//int z = x+y;
	//System.out.println(z);
	
	byte x = 3;
	int y = 4;
	//System.out.println(x+y);
	//byte z = x+y;错误: 不兼容的类型: 从int转换到byte可能会有损失
	int z = x+y;
	System.out.println(z);
}

}

2，强制转换(从大到小的转换)
-格式：目标类型变量名 = (目标类型)(要转换的结果);
-注意：不要随意使用强制准换，因为它隐含了精度损失。
class Demo2{
public static void main(String[] args){
byte x = 4;
byte y = 5;
byte z = (byte)(x+y);
System.out.println(z);

	//不要随意使用
	byte a = 99;
	byte b = 100;
	byte c = (byte)(a+b);
	System.out.println(c);
}

}

3，思考题
-看下面代码有没有问题
double d = 12.345;
float f = d;
会报错，可以使用强转。
-看下面定义有没有区别？
float f1 = (float)12.34;
float f2 = 12.34F;
f1是通过一个double类型转换而来的
f2本身就是一个float类型
-看下面代码有没有问题？
byte b1=3,b2=4,b;
b=b1+b2;
和
b=3+4;
那句代码会报错？为什么？
b=b1+b2;会报错
因为变量相加，会有类型提升，最后是int类型，赋值给byte所以报错
而常量相加，先加，看结果是否在赋值的变量的范围内，如果在范围就赋值，
不在范围才会报错。
class Demo3{
public static void main(String[] args){
byte b1=3,b2=4,b;
//b=b1+b2; 报错
//b=3+4;
//b=b1+4;报错
System.out.println(b);
}
}
-byte b = 130有没有问题？如何可以不报错？结果是多少？
class Demo4{
public static void main(String[] args){
byte b = (byte)130;
System.out.println(b);//-126
/*
130的二进制：
原码：00000000 00000000 00000000 100000010
反码：00000000 00000000 00000000 100000010
补码：00000000 00000000 00000000 100000010
进行截取
补码：1 00000010
反码：1 00000001
原码：1 11111110 64+32+16+8+4+2=-126
*/
}
}

4，字符参与运算
/*
ascii表：在这个表中，所有的字符都有一个对应的固定的十进制的数值
‘a’ 97
‘A’ 65
‘0’ 48
*/
class Demo5{
public static void main(String[] args){
System.out.println(‘a’);//a
System.out.println(‘a’+1);//98 ‘a’=97
}
}

5,字符串参与+运算
/*
当字符串遇到+，它不在是加法运算，
而是变成了字符串连接符。把+左边和右边链接到一起，
变成一个新的字符串
*/
class Demo6{
public static void main(String[] args){
System.out.println(“a”);
System.out.println(“a”+1);//a1
System.out.println(1+“a”);//1a
System.out.println(“a”+‘b’+1);//ab1
System.out.println(‘b’+1+“a”);//99a

	int a = 4;
	int b = 5;
	//System.out.println("a="+a);
	//System.out.println("b="+b);
	System.out.println("a="+a+",b="+b);
}

}

二，运算符
1，概述
-运算：对常量或者变量进行操作的过程
-运算符：对常量或者变量进行操作的过程中使用的符号

2，分类
-算术符运算符
-赋值运算符
-比较运算符(关系运算符)
-逻辑运算符
-位运算符
-三元运算符

3，算术运算符

- - / % ++ –
    -注意：整数相除只能得到整数
    如果我要得到浮点数，必须把数据变成浮点数
    /获取的是商，%获取的数余数
    class Demo7{
    public static void main(String[] args){
    int a = 5;
    int b = 2;
    System.out.println(a+b);
    System.out.println(a-b);
    System.out.println(a*b);
    System.out.println(a/b);
    System.out.println(a%b);
  System.out.println(a*1.0/b);
  }
  }

/*
++和–
作用：对变量进行自增1或者自减1
单独使用的时候，放前放后效果一样
参与运算的时候前后不一样
前：先自增或者自减，然后参与运算
后：先参与运算，然后自增或者自减
*/
class Demo8{
public static void main(String[] args){
//System.out.println(5++);错误: 意外的类型
/*int a = 5;
//a++;
++a;
System.out.println(a);
*/

	int a = 3;
	int b = 4;
	//int c = a++;
	//int d = b--;
	int c = ++a;
	int d = --b;
	System.out.println("a="+a+",b="+b+",c="+c+",d="+d);
}

}

-练习：
int a = 5;
int b = 5;
int c = 5;
a = b++;
c = --a;
b = ++a;
a = c–;
问a,b,c的结果分别是多少？

int a = 5;
int b = (a++)+(++a)+(a*2);
问a,b的结果分别是多少？

-运算符的优先级
()的优先级很高，所以在运算的时候要改变运算顺序的化可以使用()
-+号的3种用法
加法运算
遇到字符串变连接符
正号

4,赋值运算符
= += -= *= /= %=
=:是基本的赋值运算符把=符号右边的值赋值给左边的变量
其他都是扩展的把符号左边和右边进行运算，把结果赋值给左边的变量
class Demo9{
public static void main(String[] args){
//int x = 5;
//int a,b;
//a = b = 6;

	int x = 5;
	x += 6;    
	System.out.println("x="+x);
}

}

-相关问题
short s = 1;s=s+1;
和
short s = 1;s+=1;
有没有问题？如何解决？有没有区别？
第一个会报错，可以强转。
第二步不会报错
s+=1; 感觉好像是 s=s+1
实际是 s = (short)(s+1);
说明了扩展的运算符其实都隐含了强制类型转换

class Demo10{
public static void main(String[] args){
//short s = 1;
//s=s+1; 报错了
//s = (short)(s+1);
short s = 1;
s+=1;
System.out.println(“s=”+s);
}
}

5，比较运算符(关系运算符)
== != < <= >= > instanceof（判断是否是类的对象）
-注意：比较运算符的结果都是 boolean类型要么true 要么false
class Demo11{
public static void main(String[] args){
int x = 4;
int y = 5;
int z = 4;

	System.out.println(x==y);
	System.out.println(x!=y);
	System.out.println((x+y)==(x+z));
	System.out.println(x>y);
	System.out.println(x<y);
	
	boolean boo = x==y;
	System.out.println(boo);
	
	System.out.println("abc" instanceof String);
}

}

6,逻辑运算符
&:逻辑与
|:逻辑或
^:逻辑异或
!:逻辑非
&&:逻辑双与(短路与)
||:逻辑双或(短路或)
-逻辑运算符是用来链接boolean类型的值或者表达式的。
28>age>18 在java中不能直接这样写
age>18 & age<28
-表达式：就是用运算符把常量或者变量链接起来符合java语法的式子
算术表达式： a+b
比较表达式： a==b

/*
&:有假则假
|:有真则真
^:相同为假，不同为真谈恋爱
!:非真则假，非假则真。偶数个不变，奇数个取反。
&&：有假则假
||：有真则真
*/
class Demo12{
public static void main(String[] args){
int a = 4;
int b = 5;
int c = 6;
//&
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
System.out.println("----------------------------");

	//|
	System.out.println((a>b)|(a>c));//false | false = false
	System.out.println((a>b)|(a<c));//false | true = true
	System.out.println((a<b)|(a>c));//true | false = true
	System.out.println((a<b)|(a<c));//true | true = true
	System.out.println("----------------------------");
	
	//^
	System.out.println((a>b)^(a>c));//false ^ false = false
	System.out.println((a>b)^(a<c));//false ^ true = true
	System.out.println((a<b)^(a>c));//true ^ false = true
	System.out.println((a<b)^(a<c));//true ^ true = false
	System.out.println("----------------------------");
	
	//!
	System.out.println(!(a>b));//!false = true
	System.out.println(!(a<b));//!true = false
	System.out.println(!!(a>b));//!!false = false
	System.out.println(!!!(a>b));//!!!false = true
	System.out.println("----------------------------");
	
	
	//&&
	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
	System.out.println("----------------------------");
	
	//||
	System.out.println((a>b)||(a>c));//false || false = false
	System.out.println((a>b)||(a<c));//false || true = true
	System.out.println((a<b)||(a>c));//true || false = true
	System.out.println((a<b)||(a<c));//true || true = true
	System.out.println("----------------------------");
}

}

/*
&和&&以及|和||的区别
&:左边无论真假，右边都会执行
&&：左边是真，右边执行。左边是假，右边不执行。

|:左边无论真假，右边都会执行
||：左边是真，右边不执行。左边是假，右边执行。

实际开发常用 && 和 ||
*/
class Demo13{
public static void main(String[] args){
int a = 4;
int b = 5;

	//boolean boo = (a++ == 4)&(b++ == 5);
	//boolean boo = (a++ == 4)&&(b++ == 5);
	
	//boolean boo = (++a == 4)&(b++ == 5);
	boolean boo = (++a == 4)&&(b++ == 5);
	System.out.println(boo);
	System.out.println("a="+a+",b="+b);
	
}

}

7，三元运算符
-格式：比较表达式?表达式一:表达式二;
-执行流程：
先看比较表达式的结果是真还是假
如果是真最后取表达式一的值，
如果是假最后取表达式二的值。
class Demo14{
public static void main(String[] args){
int x = 55;
int y = 666;
int z = x>y?x:y;
System.out.println(“z=”+z);
}
}

class Demo14{
public static void main(String[] args){
//获取3个中最大的值
int x = 55;
int y = 666;
int z = 123;

	//分2步
	//int temp = x>y?x:y;
	//int max = temp>z?temp:z;
	
	int max = x>y?x>z?x:z:y>z?y:z;
	int max1 = (x>y)?(x>z?x:z):(y>z?y:z);
	System.out.println("max="+max);
	System.out.println("max1="+max1);
}

}