三、Java中的基本数据类型转换和常见运算符【20220610】

毕毕鸭

已于 2022-06-14 14:18:38 修改

阅读量124

点赞数

分类专栏： Java基础学习文章标签： p2p 网络协议网络

于 2022-06-10 16:35:36 首次发布

本文链接：https://blog.csdn.net/weixin_52432081/article/details/125220949

版权

Java基础学习专栏收录该内容

18 篇文章 0 订阅

订阅专栏

1.java中的基本数据类型转换

基本数据类型 [byte short int long float double boolean char]

1.boolean是不能参与基本类型转换的。
boolean类型的数据，不能被转换成任何基本类型，其他的基本类型也不能转换成boolean类型。

2.基本数据类型的精度排序[由低到高] byte short char int long float double

3.隐式数据类型转换——数据类型精度低的类型转换成数据类型精度高的类型
怎么转：直接赋值
【将数据类型精度低的类型变量/具体数据值直接赋值给数据类型精度高的类型变量】

//测试基本数据类型转换的java类
public  class  DataTypeSwitch{
	//程序的入口--主方法
	public  static  void  main(String args[]){
		//1.boolean是不能参与基本类型转换的
		//2.byte  short  char  int  long  float  double
        //隐式数据类型转换——数据类型精度低的类型转换成数据类型精度高的类型
		//将数据类型精度低的类型变量/具体数据值直接赋值给数据类型精度高的类型变量
		//int  --  double
		int  intvalue = 12;
		double doublevalue = intvalue;
		System.out.println("doublevalue=="+doublevalue); //12.0		
		//没有使用变量保存的整数值，就是int型
		double  doublevalue2=123;
		System.out.println("doublevalue2=="+doublevalue2); //123.0
	}
}

4.显式数据类型转换——数据类型精度高的类型转换成数据类型精度低的类型
显式数据类型转换也叫强制数据类型转换
怎么转：低类型低变量=(低类型)高精度变量/数据值

//测试基本数据类型转换的java类
public  class  DataTypeSwitch{
	//程序的入口--主方法
	public  static  void  main(String args[]){
		//1.boolean是不能参与基本类型转换的
		//2.byte  short  char  int  long  float  double
		//显式数据类型转换----数据类型精度高的类型转换成数据类型精度低的类型
	  	//显式数据类型转换也叫强制数据类型转换
	    //怎么转：低类型  低变量=(低类型)高精度变量/数据值
        //double -- int 
		double  doublevalue3=12.5;
		int  intvalue2=(int)doublevalue3;
		System.out.println("intvalue2=="+intvalue2); //12
		//没有使用变量保存的小数值，就是double型
		int intvalue3=(int)168.5;
		System.out.println("intvalue3=="+intvalue3); //168
	}
}

5.char字符型与int整数型之间的相互转换
char字符型——int整数型——隐式数据类型转换

//测试基本数据类型转换的java类
public  class  DataTypeSwitch11{
	//程序的入口--主方法
	public  static  void  main(String args[]){
               //char字符型--int整数型--隐式数据类型转换
               char charvalue='人';
               int value1=charvalue;
               System.out.println("value1=="+value1);  //20154
      }
}

int整数型——char字符型——显式数据类型转换也叫强制数据类型转换

//测试基本数据类型转换的java类
public  class  DataTypeSwitch11{
	//程序的入口--主方法
	public  static  void  main(String args[]){
               //int整数型---char字符型---显式数据类型转换也叫强制数据类型转换
               int value2=20154;
               char charvalue2=(char)value2;
               System.out.println("charvalue2==="+charvalue2);
      }
}

2.赋值运算符与赋值表达式的说明和用法

赋值运算符：=
   赋值表达式：变量 = 数据值
   说明：= 是赋值运算符号，将“=”右边的数据，交给“=”左边的变量来保存
例如：int num1 = 100;
   注意：所赋予变量的数据值一定要和变量的数据类型一致

3.算术运算符与算术表达式的说明和用法

算术运算符: + - * / %[求余] ++【自增】 --【自减】
算术运表达式: 100+10，12-8，23*5，10/2，10%3
说明:将运算数据值使用算术运算符合连接组成一个可计算的数式

//测试基本的算术运算符
public  class  SuanShu{
	//主方法
	public static void  main(String  args[]){
		//基本的算术运算符
		//+ - * / %[求余]
		int num1=10;
		int num2=3;
		int  he=num1+num2; //使用“+”运算符
		int  cha=num1-num2; //使用“-”运算符
		int  ji=num1*num2; //使用“*”运算符
		int  shang=num1/num2; //使用“/”运算符
		int  yu=num1%num2; //使用“%”运算符
		System.out.println(num1+"+"+num2+"="+he);
		System.out.println(num1+"-"+num2+"="+cha);
		System.out.println(num1+"*"+num2+"="+ji);
		System.out.println(num1+"/"+num2+"="+shang);
		System.out.println(num1+"%"+num2+"="+yu);
	}
}

4.”++”与”--”的具体用法

【++】与【--】都是算术运算符号
++【自增】：自动加1
表现1：变量 ++ [先用后加]
先将变量原来的数据值取出使用，使用完毕以后自动加1，下一次使用这个变量的时候就是加1以后的数据值。

//测试基本的算术运算符
public  class  SuanShu{
	//主方法
	public static void  main(String  args[]){
               //测试++
               int  number1=10;
               //变量 ++  [先用后加]
               System.out.println("number1++----"+(number1++)); //10
               System.out.println("number1----"+number1);  //11
	}
}

表现2：++ 变量 [先加后用]
先将变量原来的数据值取出加1，然后再去使用。

//测试基本的算术运算符
public  class  SuanShu{
	//主方法
	public static void  main(String  args[]){
                //测试++
                int  number1=10;
                //++ 变量  [先加后用]
                System.out.println("++number1----"+(++number1)); //11
                System.out.println("number1----"+number1);  //11
	}
}

--【自减】：自动减1
表现1：变量 -- [先用后减]
先将变量原来的数据值取出使用，使用完毕以后自动减1，下一次使用这个变量的时候就是减1以后的数据值。

//测试基本的算术运算符
public  class  SuanShu{
	//主方法
	public static void  main(String  args[]){
               //测试--
               int  number2=10;
               //变量 --  [先用后减]
               System.out.println("【number2--】----"+(number2--)); //10
               System.out.println("number2----"+number2);  //9
          } 
}

表现2：-- 变量 [先减后用]
先将变量原来的数据值取出减1，然后再去使用。

//测试基本的算术运算符
public  class  SuanShu{
	//主方法
	public static void  main(String  args[]){
               //测试--
                int  number2=10;
               //-- 变量  [先减后用]
               System.out.println("【--number2】----"+(--number2)); //9
               System.out.println("number2----"+number2);  //9
          } 
}

5.关系运算符与关系表达式的说明和用法

关系运算符: > < >= <= !=
关系表达式: 100>10，12<8，23>=5，10<=2，10!=3
关系运算符也叫比较运算符，它的运算结果是boolean类型

//测试基本的比较运算符
public  class  BiJiao{
	//主方法
	public static void  main(String  args[]){
		//基本的比较运算符
		//> <  >=  <= !=
		//关系运算符也叫比较运算符，它的运算结果是boolean类型
		int  num1=10;
		int  num2=3;
		boolean dayu=num1 > num2; //使用“>”比较运算符
		boolean xiaoyu=num1 < num2; //使用“<”比较运算符
		boolean dayudengyu=num1 >= num2; //使用“>=”比较运算符
		boolean xiaoyudengyu=num1 <= num2; //使用“<=”比较运算符
		boolean budengyu=num1 != num2; //使用“!=”比较运算符
		System.out.println(num1+">"+num2+"-----"+dayu);
		System.out.println(num1+"<"+num2+"-----"+xiaoyu);
		System.out.println(num1+">="+num2+"-----"+dayudengyu);
		System.out.println(num1+"<="+num2+"-----"+xiaoyudengyu);
		System.out.println(num1+"!="+num2+"-----"+budengyu);
	}
}

6.逻辑运算符与逻辑表达式的说明和用法

常见的逻辑运算符：或【||】与【&&】非[取反]【!】
逻辑表达式: true || false ，(10>3) && (12<5) ，!(100<5)
参与逻辑运算的数据值和逻辑运算的结果都是boolean类型

//测试基本的逻辑运算符
public  class  LuoJi{
	//主方法
	public static void  main(String  args[]){
		//基本的逻辑运算符
		// ||  &&  ！
		//参与逻辑运算的数据值和逻辑运算的结果都是boolean类型
		int  num1=10;
		int  num2=3;
		boolean huo=(num1>num2) || (num1<num2); //使用“||”逻辑运算符
		boolean yu=(num1<num2) && (num2<num1); //使用“&&”逻辑运算符
		boolean fei=!((num1<num2) && (num2<num1)); //使用“!”逻辑运算符
		System.out.println("||[或]---"+huo); //true || false -- true
		System.out.println("&&[与]---"+yu); //false && true --  false
		System.out.println("！[非]---"+fei); //!false---true
	}
}

7.短路或和短路与

我们将逻辑或也叫短路或，将逻辑与也叫短路与。
短路的意思就是逻辑运算符合的左右两边，有一边不需要计算。

逻辑或也叫短路或
true || false --- true
true || true --- true
false || true --- true
false || false ---false
逻辑或的左边为true,右边不需要计算，其结果一定是true

//测试短路运算符
public  class  DuanLu{
	//主方法
	public static void  main(String  args[]){
		//System.out.println(10/0); //java.lang.ArithmeticException: / by zero
		//测试短路或
		//左边为true,右边不需要计算，其结果一定是true
		System.out.println(true || ((10/0)>1)); //true
           }
}

逻辑与也叫短路与
true && false --- false
   true && true --- true
   false && true --- false
   false && false ---false
   逻辑与的左边为false,右边不需要计算，其结果一定是false

//测试短路运算符
public  class  DuanLu{
	//主方法
	public static void  main(String  args[]){
		//System.out.println(10/0); //java.lang.ArithmeticException: / by zero
		//测试短路与
		//左边为false,右边不需要计算，其结果一定是false
		System.out.println(false && ((10/0)>1)); //false
           }
}

8.位运算符的用法

位运算符   ：将参与运算的数据转换成2进制【010101】，逐一进行运算。
   常见的位运算符：&[按位与]，|[按位或]，^[按位异或]，~[按位反]，<<[左移位]，>>[右移位]
   &[按位与]：两个二进位均为1时，结果位才为1 ，否则为0
       1&1=1 1&0=0 0&1=0 0&0=0
   |[按位或]：两个二进位有一个为1时，结果位就为1
       1|1=1 1|0=1 0|1=1 0&0=0
   ^[按位异或]：两个二进位相异时，结果为1
       1^1=0 1^0=1 0^1=1 0^0=0
   ~[按位反]: 逐位取反
   <<[左移位]：向左移动指定位数
   2---左移2位   0000 0010
0000 1000---8
   >>[右移位]：向右移动指定位数
   2---右移2位   0000 0010
0000 0000---0

//测试位运算符
public  class  WeiYunSuan{
	//主方法
	public static void  main(String  args[]){
	//位运算符	：将参与运算的数据转换成2进制【010101】，逐一进行运算。
	//常见的位运算符：&[按位与],|[按位或],^[按位异或],~[按位反],<<[左移位],>>[右移位]
	int num1=7;
	int num2=3;
	//&[按位与]：两个二进位均为1时，结果位才为1 ，否则为0
	//	   1&1=1  1&0=0 0&1=0 0&0=0
	System.out.println(num1+"-&[按位与]-"+num2+"==="+(num1&num2)); //3
	//|[按位或]：两个二进位有一个为1时，结果位就为1
	//	   1|1=1  1|0=1 0|1=1 0&0=0
	System.out.println(num1+"-|[按位或]-"+num2+"==="+(num1|num2)); //7
	//^[按位异或]：两个二进位相异时，结果为1。
	//	    1^1=0  1^0=1 0^1=1 0^0=0
	System.out.println(num1+"-^[按位异或]-"+num2+"==="+(num1^num2)); //4
	//~[按位反]: 逐位取反
	System.out.println(num1+"-^[按位取反]-"+"==="+(~num1)); //-8
	//<<[左移位]：向左移动指定位数
	System.out.println(num1+"<<2"+"==="+(num1<<2)); //28
	//>>[右移位]：向右移动指定位数
	System.out.println(num1+">>2"+"==="+(num1>>2)); //1
	}
}