Java初学笔记——2.运算符与表达式

package 运算符与表达式;
public class TestOperator {
public static void main(String[] args) {
//算术运算符
//加（+）、减（-）、乘（*）、除（/）、取余（取模）（%）、自增（++）、自减（--）
    //除（/）运算两个都是整数时表示整数除法
	int i = 3;
	int j = 2;
	System.out.println(i/j);
    //否则，表示浮点除法
	float k = 2.0f;
	System.out.println(i/k);
    //整数被零除将产生一个异常，浮点数被零除得到无穷大(Infinity)或者NaN
	//System.out.println(i/0);
	System.out.println(k/0);
	
//自增自减运算符
    //++（--）
    //++（--）在前时先运算再取值
    //++（--）在后时先取值再运算
	int i2 = i++;
	System.out.println("i="+i);
	System.out.println("i2="+i2);
	
	
//关系运算符
//关系运算符，求值结果为布尔型（Boolean）
	//==检测是否相等，如：3==7的值是false
	//！=检测是否不等，如：3！=7的值是true
	//<,>,<=,>=分别表示小于，大于，小于等于，大于等于
	System.out.println("i!=i2 is "+(i!=i2));
	
	
//布尔运算符
//布尔运算符，运算因子为布尔型，结果也是布尔型
	//表达式（expression）1&&表达式（expression）2
	//&&(逻辑与)，||（逻辑或），！（逻辑非）
	//与：都为真；或：一真为真；非：真变假假变真
	double j1=2.3;
	System.out.println("i!=i2 && j1<j? 是： "+(i!=i2 && j1<j));
	System.out.println("i!=i2 || j1>j? 是： "+(i!=i2 || j1>j));
	System.out.println("!(i!=i2 || j1>j)? 是： "+!(i!=i2 || j1>j));
	
//布尔运算符的短路
//&&和||是按短路的方式求值的，如果第一个操作数已经能够确定表达式的值，第二个操作数就不必计算了
	System.out.println("j现在的值是："+j);
	boolean result = (i<j)&&(++j == 3);// j的值是多少?就是说我们想的j应该++结果为j=3，但因为第一个操作数已经确定表达式的值了，因此j++就没有实现
	System.out.println("短路运算后j的值是多少是："+j);

	
//三元运算符
//condition(布尔型)?exp1:exp2
//condition(布尔型)为真时，计算exp1的值，为假时是计算exp2的值
	int score = 88;
	String isoK =score >= 60?"及格":"不及格";
	System.out.println("score="+score+"时，我们认为成绩： "+isoK);
//进阶版：
	String isOK =score >= 60?(score >= 85 ? "优秀":"合格"):"不及格";
	System.out.println("score="+score+"时，我们认为成绩： "+isOK);
	
	
//赋值运算符"="
//当“=”两侧数据类型不一致时，可以使用默认类型转换使用强制类型转换进行处理
//注意：可以将整形常量直接复制给byte，short，char等类型变量，而不需要进行强制类型转换，只要不超出其表述范围
//   操作符               用法举例                 等效的表达式
//   +=:                  a+=b                     a=a+b
//   -=：                 a-=b                     a=a-b
//   *=：                 a*=b                     a=a*b
//   /=：                 a/=b                     a=a/b
//   %=：                 a%=b                     a=a%b

//类型转换：
//自动类型转换（小的赋给大的）：int i = 10;      long j =200;         j=i;
//强制类型转换（大的赋给小的）（有一定的精度丢失）（int->float  long->float  long->double也会有一定的精度丢失）：int i = (int)128L
//byte、char、和short型参与运算时自动提升为int型
//对于表达式
	//如果一个操作数为long型，则整个表达式提升为long型
	//如果一个操作数为float型，则整个表达式提升为float型
	//如果一个操作数为double型，则整个表达式提升为double型
	int i3 = 222;
	float j3 = 3.14F;
	float x = 3.14f;
	j3 = j3 +0.05F;//这条语句不能写成j3=j3+0.05；否则会报错，因为0.05是double型，加上float型的j3，仍然是double型，属于大赋给小，强制赋给float型会报错
	x = (float)(x +0.05F);//强制类型转换实例
	System.out.println("3.14F + 0.05F =" + j3);
	System.out.println("3.14F + 0.05F =" + x);
	
	
//示范类型的转换
//绝对安全的赋值，即便两侧的数据类型不一致，也会发生自动类型转换
//编译器只检查语法，运行器才负责运算
	byte b =127;
	int c = 129;
	long longNum = c;
	//c = longNum;          这里编译器只检查语法错误，因此会报错
	c = (int)longNum;
	
	//float f = 123.123;        123.123默认为double，这里编译器只检查语法错误，因此会报错
	float f = 123.123f;
	
	//f =f + 1.2;           1.2默认是douible型，有一个操作数为double，整体的表达式为double，这里编译器只检查语法错误，因此会报错
	f = (float)1.2 + f;
	//或 f = (float)(1.2+f);
	
}
}