B004-表达式类型转换运算符

表达式

/**
 * 表达式定义：由常量 变量 运算符 括号组成的算式，为了按照一定的运算规则计算出结果值
 *  括号能提高运算的优先级 
 *  1.表达式结果可使用变量接收后用变量打印，也可使用表达式直接打印
 *  2.只要表达式中有一个是字符串结果就都是用字符串类型接收
 */
public class BDSDemo {
	public static void main(String[] args) {

		int a = 25;
		boolean b = true;
		// 表达式结果可直接打印
		System.out.println(a + 69 + "你们好" + b + (36 + 45));
		// 只要表达式中有一个是字符串结果就都是用字符串类型接收
		String s1 = a + 69 + "你们好" + b + (36 + 45);
		String s2 = a + 69 + "25" + b + (36 + 45);
	}
}

数据类型转换

类型转换定义：从一种数据类型转换为另外一种类型
作用：1.节约内存空间；2.转换成项目所需要的类型

基本数据类型排序
(boolean)、byte、char、short、int、long、float、double
char 只有正数范围 [0，2^16-1]

自动转换

在这里插入图片描述

/**
 *   自动转换：从小的类型转换大的类型
 *   1.布尔类型不参与转换
 *   2.byte与char之间不能自动转换，因为char只有正数范围    
 *     char与short之间不能自动转换，因为char正数范围比short大
 */
public class TypeTransform {

	public static void main(String[] args) {
		//1.如果运算式中元素类型分别属于（byte，short，char，int），那么运算前所有元素类型都将会自动转换为int类型再运算，结果也为int（自动向上转型）
		byte b = 25;
		short s = 26;
		char c = 'A';
		int i = b+s+c+69;
		System.out.println("i: "+i);
		byte b1 = 23;
		int r = b+b1;
		
		//2.long  float  double只要两个操作数中有一个为以上类型，另一个就会被转换成表达式中最大类型，并且结果也为该类型
		long  x = 36L;
		float y = 20.0F;
		float d = x+y;
		double t = x+y+3.14;
		float t1 = x+y+3.14F;
		double t2 = 69+x+y+b+c+s+2.0;
		
		//3.char类型向更高长度类型（例如整型）转换时，会转换为对应的ASCII码值，再做其他类型的自动转换
		char c1 = 'A';
		int t3 = c1+35;//根据ASCII码值为65  提升为int类型 
		System.out.println("t3: "+t3);
		
		//特例 从大到小（要在小的类型范围中） 
		byte b2 = 36;
		short s1 = 5798;
	}

}

强制转换

/**
 *   强制转换：从大的类型转换成小的类型     （是为了转换成自己或者项目所需要的的类型）
 *       语法：强转类型  变量名 = (强转类型)(值或者表达式)
 *       注意：都是已知转换不会出问题，如果是未知的强制转换就有可能出现精度损失
 */
public class TypeTransform2 {

	public static void main(String[] args) {
		byte b1 = 120;
		byte b2 = 3;
		//正常强制转换
		byte x1 = (byte)(b1+b2);
		System.out.println("x1: "+x1);
		 
		byte b3 = 120;
		byte b4 = 30;
		//出现精度损失的强制转换
		byte x2 = (byte)(b3+b4);
		System.out.println("x2: "+x2);
		 
		//byte与char不能自动转换  但是可以强转
		char c = 65;
		byte b5 = (byte)c;
		 
		int i1 = 123;
		int i2 = 456;
		//注意强转的时候强转的部分是否为一个整体
	    float d = (float)((i1 + i2) * 1.2);
	}

}

运算符

数学运算符

/**
  *  数学运算符：+(加)   -(减)   *(乘法)   /(除法)   %(取模  求余数)
  *     作用于常量或者变量
 */
public class _04MathSignDemo {

	public static void main(String[] args) {
		//加法
		System.out.println(2+50.0);
		//减法
		System.out.println(2-1);
		//乘法
		System.out.println(2*2);
		
		//除法
		System.out.println(2/2);
		//System.out.println(1/0);		//编译只看类型 不会进行运算 所以编译不会报错 运行会报错  因为0不能作为分母
		System.out.println(1.0/0);		//Infinity  0先提升为double类型  double类无限趋近于这个数字
		System.out.println(0.0/0);		//NaN  等同于无线趋近于0乘以无限大   not a number  不是一个数
		System.out.println(10/3);		//3   因为两个都是整数类型 结果也为整数类型 不会保留小数位
		
		//取模
		System.out.println(5%2);		//1
	}
}

自增自减运算符

/**
 * 自增运算符：++，只能作用于变量，使变量的值自动增加1
 * 自减运算符：--，只能作用于变量，使变量的值自动减少1
 */
public class _05AutoIncreDemo {

	public static void main(String[] args) {

		int i = 2;
		i++;
		System.out.println(i);	//3

		int j = 2;
		++j;
		System.out.println(j);	//3
		
		int x = 5;
		x--;
		System.out.println(x);	//4
		System.out.println(--x);//3
	}
}

i++与 ++i的区别

/**
 * 自增运算符：++，只能作用于变量，使变量的值自动增加1
 * i++与 ++i的区别：
 *    i++和++i本身是一个表达式，也具有值
 * 结论：
 *    i++表达式的值等于i自增之前的值，i本身的值也会+1
 *    ++i表达式的值等于i自增之后的值，i本身的值也会+1
 * 使用的时候 需要注意 到底是使用的是变量的值 还是自增表达式的值
 */
public class _06AutoIncreDemo2 {

	public static void main(String[] args) {

		int i = 2;
		System.out.println(i++);	// 2
		System.out.println("i=" + i);

		int j = 2;
		System.out.println(++j);	// 3
		System.out.println("j=" + j);
	}
}

public class Practice {
	public static void main(String[] args) {
		int i = 3;
		int a = i++ + i++ + i++;
		//      3     4     5     i=6
		int b = ++i + ++i + ++i;
		//       7     8     9    i=9
		System.out.println(i);	//9
		System.out.println( a);	//12
		System.out.println( b);	//24
	}
}

+号的特殊使用:
1.基本数据类型之间使用+号
	全部进行加法运算
2.基本数据类型和引用数据类型之间使用+号
	2.1如果基本数据类型先使用+号，那么进行加法运算，然后使用+号和字符串进行拼接
	2.2如果字符串和字符之间使用+号，那么字符不会转换成对应的数值，直接进行拼接		
3.引用数据类型和引用数据类型之间使用+号
	全部进行拼接
	如果字符串在最前面,那么后面的全部进行拼接

自增自减运算符符号：  ++    --
注意:  自增自减只能够用于变量，不能用于常量  
           自增自减运算的优先级比算术运算符高
要点:  把整个表达式看成是一个整体。
		  如果符号在变量名后面，那么整个表达式的值就是原来值不变。
		  如果符号在变量名前面，那么整个表达式的值就是原来的值加1。

赋值运算符

/**
  * 赋值运算：从右往左
 *  =  +=  -=  *=  /=  %=
 *  +=  -=  *=  /=  %= 会存在隐式的自动类型转换
 */
public class _08FZSignDemo {

	public static void main(String[] args) {

		int x = 6;

		x += 5;		//可以理解为x=x+5;
		System.out.println("x: "+x);	//11

		x -= 6;		//可以理解成x=x-6;
		System.out.println("x: "+x);	//5
		
		byte b1 = 2, b2 = 3;
		b1 = (byte) (b1 + b2);
		System.out.println(b1);

		b1 += b2;	//可以理解成为： b1=b1+b2，有一个隐式的自动类型转换

	}
}

比较运算符

/**
  * 比较运算符
 *  ==(相等)  !=(不等)  >  <  >=  <=
  *  用来两个常量或者变量或者两个表达式之间的比较
  *  比较运算的结果为布尔类型
 */
public class _09CompareDemo {

	public static void main(String[] args) {
		System.out.println(5>3);//true
		int a = 5 ,b = 6;
		System.out.println(a!=b);//true
		System.out.println(a++>b++);//false
		System.out.println(a==b);//false
	}
}

位运算符(了解)

/**
  * 位运算符(了解)
  * 主要用来进行二进制的运算，进行位运算之前，首先需要将数据转换为二进制以后再进行运算
    1. & : 与 位运算，两边为1，结果为1，不同时为1，则结果为0
	2. | : 或 位运算，有一个为1，结果为1
	3. ^ : 异或，两边不一样，就为1，否则为0
	4. ~ : 取反，1变成0，0 变成1    ~（-5）结果4
	5. <<：向左位移动，例如1<<3，   结果8         
	6. >>：向右位移动，例如8>>2     
	7. >>>：无符号向右移动
 */
public class _10BinSignDemo {

	public static void main(String[] args) {
		
		//&：先转为二进制去算，同时为1则为1，其他都为0
		System.out.println(2&3);	//结果为二进制的10，  10进制就为2
		/*  10
		 *  11
		 * ----
		 *  10
		 * */
	    //|：有一个为1 则为1 
		System.out.println(2|3);	//11=1*2^1+1*2^0=1+2=3
		//^：两边不一样才为1
	    System.out.println(2^3);	//01  -->1
	    //<<：往左移动3位，补0
	    System.out.println(1<<3);	//1000=1*2^3=8
	    //>>：往右移动3位
	    System.out.println(8>>3);	//1
	}
}

逻辑运算符

/**
  *  逻辑运算符:
  *    用来连接两个布尔类型的值或者表达式，运算的最终结果也为布尔类型
 *  &：与  两个表达式同时为true，则结果为true，否则结果为false
 *  |：或  只要有一个为true，则逻辑运算结果为true
 *  !: 取反
 *  ^：亦或  必须两个不同的时候  逻辑运算才true
 *  &&：短路与  两个表达式同时为true，则结果为true，第一个为false后面的就不用运行
 *  ||：短路或  只要有一个为true，逻辑运算结果为true，第一个为true后面的就不用运行
 */
public class _11LogicDemo {

	public static void main(String[] args) {
		System.out.println(true&true);	//true
		System.out.println(true&false);	//false
		System.out.println(true|false);	//true
		System.out.println(false|false);//false
		System.out.println(!true);		//false
		System.out.println(true^false);	//true
		System.out.println(false^false);//false
		System.out.println(true^true);	//false
		System.out.println(true&&true);	//true
		System.out.println(true&&false);//false
		System.out.println(true||true);	//true
		System.out.println(true||false);//true
	}
}

/**
 *  && 和 & 区别?
 *   &不具有短路功能，当第一部分为false的时候， 依然会执行第二部分的代码
 *   &&具有短路功能，当第一部分为false的时候，不会执行第二部分
 *  | 和 || 区别?
 *   |不具有短路功能,当第一部分为true时，依然会执行第二部分
 *   ||具有短路功能，当第一部分为true时，不会执行第二部分
 */
public class _12LogicDemo2 {

	public static void main(String[] args) {

		int x = 5;
		System.out.println(3>5 & x++>6);	//false
		System.out.println(x);	//6
		
		int y = 5;
		System.out.println(3>5 && y++>6);	//false
		System.out.println(y);	//5	
		
		int i = 4;
		System.out.println(5>3|i++>2);	//true
		System.out.println(i);	//5
		
		int j = 4;
		System.out.println(5>3||j++>2);	//true
		System.out.println(j);	//4
	}
}

三目运算符

/**
 * 三目运算符：由?和:分隔的三个表达式 
 * 语法：x?y:z， x:布尔类型的值或者表达式， y和z，一般来说为同种类型的变量 常量或者表达式
 * 运算流程：当x为true的时候，三目运算的结果为y，否则为z
 */
public class _13ThreeEyesDemo {

	public static void main(String[] args) {
		// 三目运算
		String s = false ? "真的" : "假的";
		System.out.println(s);
		// 不能使用变量接收 因为编译只看类型 不会运算
		System.out.println(false ? "真的" : 4);

// 		求出a和b两个整数中最大的整数
		int a = 69, b = 138;
		System.out.println(a > b ? a : b);

// 		求出 a,b,c 三个数中最小的数字
		// 两两比较 先找出两者中最小的 再将结果和第三个进行比较
		int x = 9, y = -6, z = -1;
		int t = x < y ? x : y;
		int min = t < z ? t : z;
		System.out.println(min);
		
//		例如小明学习java 考试成绩  >=60 显示 非常优秀   否则输出 还有很大的提升空间。
		// 定义一个变量 用来存放小明成绩
		int score = 99;
		String s2 = score >= 60 ? "非常优秀" : "还有很大提升空间";
		System.out.println(s2);
		
//		等级分   A B C D ,也是通过三目运算写出结果
		/*
		 * 90~100 A score>=90&&score<=100 
		 * 80~90 B score>=80&&score<90 
		 * 70~80 C score>=70&&score<80 
		 * 60~70 D score>=60&&score<70
		 */
		// 三木运算嵌套
		String s3 = score >= 90 && score <= 100 ? "A" : (score >= 80 && score < 90 ? "B" : (score >= 70 && score < 80 ? "C" : "D"));
		System.out.println(s3);
	}
}