Java语言基础(3)

1 算术运算符：+，-，*（乘法），/（除法），%（求余数）
　　1）只有相同类型的数据才可以进行算术运算，经常使用到自动类型转换和强制类型转换，把参与运算的数据转换为同一个类型，然后再进行算术运算。
　　　　案例：Demo1

public class Demo1 {
  public static void main(String[] args) {
	int num1=100,num2=200;
	int sum1 = num1+num2;
//num1，num2都是int类型，直接进行加法运算	
	System.out.println("sum1="+sum1);
	int num3=10;
	double num4=100.6;
	double result = num4-num3;
//分析：首先num4是double，而num3是int，num3进行
//自动类型转换，由当前的int类型自动的转换为double
//类型（10--->10.0），然后执行减法运算，最后把
//运算的结果赋值给result（90.6）
	System.out.println("result="+result);
	int num5=100;
	double num6=1.66;
	double result2 = num5*num6;
//num5进行自动类型转换int--》double
//				  (100-->100.0)
	System.out.println("result2="+result2);
	int num7=100,num8=10;
	int result3 = num7/num8;
	System.out.println("result3="+result3);
  
    int num9=10;
    float num10=10.99f;
    int result4 = num9+(int)num10;
//    						10
    System.out.println("result4="+result4);
  }
}

　　2）算术运算的结果跟参与运算数据的类型（统一类型）一致
　　　　案例：Demo2

public class Demo2 {
  public static void main(String[] args){
	int num1=10,num2=4;
	double result = num1/num2;
//分析：首先num1和num2都是int类型，所以算术运算
//结果也是int类型，结果是2，然后2进行自动类型转换，
//由当前的int类型自动的转换为double类型（2->2.0）
//最后把2.0赋值给result	
	System.out.println("result="+result);
  }
}

　　3）%：求出余数
　　　　被除数 = 商 * 除数 + 余数
　　　　余数 = 被除数 - 商 * 除数
　　　　eg：
　　　　　　int num1=10,num2=3;
　　　　　　int result1=num1/num2; //3
　　　　　　int result2=num1%num2; //1
　　　　　　案例：Demo3

public class Demo3 {
  public static void main(String[] args) {
	int num1=10,num2=3;
	int result1 = num1/num2;//3
	System.out.println("result1="+result1);
    int result2 = num1%num2;//1
    System.out.println("result2="+result2);
  
    int num3=100,num4=10;
    int result3 = num3/num4;//10
    System.out.println("result3="+result3);
    int result4 = num3%num4;//0
    System.out.println("result4="+result4);
  }
}

　　　　a）整除余数是0
　　　　b）负数的余数，依然是负数（整除例外）
　　　　　　案例：Demo4

public class Demo4 {
//负数的余数，依然是负数（整除例外）
  public static void main(String[] args) {
	int num1=-100,num2=3;
	int result1 = num1/num2;//-33
	System.out.println("result1="+result1);
	int result2 = num1%num2;//-1
	System.out.println("result2="+result2);
  }
}

　　　　eg：
　　　　　　int num1=-10，num2=-3；
　　　　　　int result = num1/num2; //3
　　　　　　int result = num1%num2;
　　　　　　余数 = 被除数 - 商*除数
　　　　　　　　 = -10 - （-3）*3
　　　　　　　　 = -10 - （-9）
　　　　　　　　 = -10 + 9
　　　　　　　　 = -1
　　　　c）小数的余数，依然是小数
　　　　　　案例：Demo5

public class Demo5 {
  public static void main(String[] args) {
	double num1=10.666;
	int num2=10;
	double result = num1%num2;//0.666
	System.out.println("result="+result);
  }
}

2 自增运算符：++
　　1）变量的值和表达式的值
　　　　eg：
　　　　　　int a =100；
　　　　　　变量a的值是100
　　　　　　表达式a+1的值是101
　　2）前置的自增：
　　　　++i：首先i先加1（i=i+1），然后把i当前的值作为++i整个表达式的值
　　　　eg：
　　　　　　int num=10；
　　　　　　int result = ++num；
　　　　　　分析：首先num=num+1（11），然后把num当前的值作为++num整个表达式的值（11），最后把++num表达式的值（11）赋值给变量result（11）
　　　　案例：Demo6

public class Demo6 {
//++i:首先i=i+1，然后把i加完以后的值作为++i整个
//表达式的值。	
  public static void main(String[] args) {
	int num = 100;
	int result = ++num;
//分析：首先num=num+1（101），然后把num当前的值
//作为++num整个表达式的值（101），最后把++num
//表达式的值赋值给result（101）
	System.out.println("num="+num);
	System.out.println("result="+result);
  }	
}

//Demo7:
//int num = 10;
//int sum = ++num + ++num + ++num;
//sum = ?
public class Demo7 {
  public static void main(String[] args) {
	int num = 10;
	int sum = ++num + ++num + ++num;
//				11		12		13
//			变量		表达式
//第1个表达式：11		11	
//第2个表达式：12		12
//第3个表达式：13		13	
	System.out.println(sum);
  }
}

//Demo8
//int num=100;
//int sum = ++num + ++num + ++num + ++num?
//sum = ?  
public class Demo8 {
  public static void main(String[] args) {
	int num=100;
  int sum = ++num + ++num + ++num + ++num;
//  		101		102		103		104
// 				变量		表达式
//第1个表达式：   	101		101
//第2个表达式：	102		102  
//第3个表达式：	103  	103
//第4个表达式：  	104		104
    System.out.println(sum);
  }
}

　　3）后置的自增：
　　　　i++：首先把i当前的值作为i++整个表达式的值，然后i再加1（i=i+1）
　　　　eg：
　　　　　　int num=100;
　　　　　　int result = num++;
　　　　　　分析：首先把num当前的值作为num++整个表达式的值（100），然后num=num+1（101），最后把num++表达式的值（100）赋值给result
　　　　案例：Demo9

public class Demo9 {
//i++：首先把i当前的值作为i++整个表达式的值，然后
//i=i+1	
  public static void main(String[] args) {
	int num = 1000;
	int result = num++;
//分析：首先把num当前的值作为num++整个表达式的值
//（1000），然后num=num+1（1001），最后把num++
//表达式的值赋值给result
	System.out.println("num="+num);
	System.out.println("result="+result);
  }
}

//Demo10
//int num = 100;
//int sum = num++ + num++ + num++;
//sum = ?   
public class Demo10 {
  public static void main(String[] args) {
	int num = 100;
	int sum = num++ + num++ + num++;
//			   100	   101     102
//			  变量	表达式
//第1个表达式： 101		100
//第2个表达式： 102	    101
//第3个表达式： 103		102
	System.out.println(sum);
  }
}

//Demo11
//int num=10;
//int sum = ++num + ++num + num++ + num++;
//sum = ?
public class Demo11 {
  public static void main(String[] args) {
	int num=10;
  int sum = ++num + ++num + num++ + num++;
//  		11		12		12		13
//  			变量		表达式
//第1个表达式：	11		11
//第2个表达式：	12  	12
//第3个表达式：	13      12 
//第4个表达式：	14		13
    System.out.println(sum);
  }
}

3 自减运算符：--
　　1）前置自减：
　　　　--i：首先i=i-1，然后把i当前的值作为--i整个表达式的值。
　　　　eg：
　　　　　　int num = 10;
　　　　　　int result = --num;
　　　　　　分析：首先num=num-1（9），然后把num当前的值（9）作为--num整个表达式的值（9），最后把--num表达式的值赋值给result（9）
　　　　案例：Demo12

public class Demo12 {
//--i：首先i=i-1，然后把i减完以后的值作为--i整个
//表达式的值
  public static void main(String[] args) {
	int num = 1000;
	int result = --num;
//首先num=num-1（999），然后把num当前的值（999）
//作为--num整个表达式的值（999），最后把--num
//表达式的值赋值给result（999）
	System.out.println("num="+num);
	System.out.println("result="+result);
  }
}

//Demo13
//int num = 100;
//int sum = --num + --num + --num;
//sum = ?
public class Demo13 {
  public static void main(String[] args) {
	int num = 100;
	int sum = --num + --num + --num;
//	           99		98		97
//				变量		表达式
//第1个表达式：	99		99
//第2个表达式：	98		98
//第3个表达式：	97		97
	System.out.println(sum);
  }
}

//Demo14
//int num=100
//int sum = num++ + num++ + --num + --num;
//sum = ?
public class Demo14 {
  public static void main(String[] args) {
	int num = 100;
  int sum = num++ + num++ + --num + --num;
//  		100		101		101      100
//				变量		表达式
//第1个表达式：  	101		100
//第2个表达式：	102     101
//第3个表达式：        101     101
//第4个表达式：	100     100
    System.out.println(sum);
  }
}

　　2）后置自减：
　　　　i--：首先把i当前的值作为i--整个表达式的值，然后i=i-1
　　　　eg：
　　　　　　int num = 100;
　　　　　　int result = num--;
　　　　　　分析：首先把num当前的值作为num--整个表达式的值（100），然后num=num-1（99），最后把num--整个表达式的值赋值给result（100）
　　　　案例：Demo15

public class Demo15 {
//i--：首先把i当前的值作为i--整个表达式的值，然后
//i=i-1
  public static void main(String[] args) {
	int num = 10;
	int result = num--;
//分析：首先把num当前的值作为num--整个表达式的值
//(10)，然后num=num-1(9)，最后把num--表达式的值
//赋值给result
	System.out.println("num="+num);
	System.out.println("result="+result);
  }	
}

//Demo16:
//int num = 100;
//int sum = --num + --num + num--;
public class Demo16 {
  public static void main(String[] args) {
	int num = 100;
	int sum = --num + --num + num--;
//				99		98		98
//				变量		表达式
//第1个表达式：	99		99
//第2个表达式：	98		98
//第3个表达式：	97	    98
	System.out.println(sum);
  }
}

//Demo17
//int num=100;
//int sum = num++ + num++ + num-- + num--;
//sum = ?
public class Demo17 {
  public static void main(String[] args) {
	int num = 100;
  int sum = num++ + num++ + num-- + num--; 
//  		100		101		102		101
//  			变量		表达式
//第1个表达式：  	101		100
//第2个表达式：  	102		101
//第3个表达式：	101  	102
//第4个表达式：  	100		101
  	System.out.println(sum);
  }
}

//Demo18
//int num = 100;
//int sum = ++num + num++ + --num + num--;
//sum = ?  
public class Demo18 {
  public static void main(String[] args) {
	int num = 100;
  int sum = ++num + num++ + --num + num--;
//  		101		101		101		101
//  			变量		表达式
//第1个表达式：  	101		101
//第2个表达式：	102     101
//第3个表达式：	101		101
//第4个表达式：	100		101
    System.out.println(sum);
  }
}

　　总结：
　　　　无论前置自增还是后置自增，变量都会加1，不同仅仅只是表达式的值。
　　　　无论前置自减还是后置自减，变量都会减1，不同仅仅只是表达式的值。

4 复合赋值运算符：+=,-=,*=,/=,%=
　　eg:
　　　　int num=100;
　　　　num += 10; // num = num+10
　　　　num -= 20; // num = num-20
　　　　num *= 100; // num = num*100
　　　　num /=10; // num = num/10

　　　　int num2=200;
　　　　num += num2-100; // num = num+(num2-100)
　　　　num /= num2+100; // num = num / (num2+100)
　　　　num %= num2/100; // num = num % (num2/100)
　　案例：Demo19

public class Demo19 {
//复合赋值运算符：+=,-=,*=,/=,%=
  public static void main(String[] args) {
	int num1=100;
//	num1 += 200; //num1=num1+200
//	System.out.println(num1);
//	num1 *= 10;  //num1=num1*10
//	System.out.println(num1);
	int num2=200;
//	num1 -= num2/100;
//	num1 = num1 - (num2/100)
//	System.out.println(num1);
	num1 /= num2/100;
//	num1 = num1 / (num2/100)
	System.out.println(num1);
  }
}

5 关系运算符： >,>=(大于或者等于),<,<=(小于或者等于),==(等于)，!=(不等于)
　　1）关系表达式：使用关系运算符连接的表达式，称为关系表达式，关系表达式最终必须返回一个boolean类型结果，要么true，要么false。
　　　　eg：
　　　　　　int num1=100,num2=200;
　　　　　　boolean result1 = num1>num2;　　//false
　　　　案例：Demo20

public class Demo20 {
  public static void main(String[] args) {
	int num1=100,num2=500;
	boolean result1 = num1==num2;
//						 false
	System.out.println("result1="+result1);
	boolean result2 = num1!=num2;
//						 true
	System.out.println("result2="+result2);
    boolean result3 = num1>num2;
//    					 false
    System.out.println("result3="+result3);
    boolean result4 = num1<=num2;
//    			         true
    System.out.println("result4="+result4);
  }
}

　　2）运算符的优先级：
　　　　算术运算符>关系运算符>赋值运算符
　　　　eg：
　　　　　　int num1=100,num2=200;
　　　　　　boolean result = (num1-50)*3+100>=num2;
　　　　　　　　　　　　算术　　   50 *3 +100>=num2
　　　　　　　　　　　　　　　　　　　　250>=num2
　　　　　　　　　　　　关系　　　　　　　            true
　　　　　　　　　　　　赋值 把true赋值给result
　　　　案例：Demo21

public class Demo21 {
//运算符优先级：算术运算符>关系运算符>赋值运算符
  public static void main(String[] args) {
	int num1=100,num2=200,num3=1000;
	boolean result = 
		(num1*4+200)*2-num2 >= num3;
//算术	   (400+200)*2-num2 >= num3
//			     600*2-num2 >= num3
//		          1200-200  >= num3
//					1000    >= num3
//关系				true
//赋值	把true赋值给result
	System.out.println("result="+result);
  }
}