JAVA笔记-运算符

运算符分为

1. 算数运算符
2. 关系运算符
3. 逻辑运算符
4. 赋值运算符
5. 三元运算符
6. 位运算符

算数运算符

		// 	+ 号的使用
		System.out.println(10+4);//结果=14

		// 	- 号的使用
		System.out.println(10-4);//结果=6

		// 	* 号的使用
		System.out.println(10*4);//结果=40

		// 	/ 号的使用
		System.out.println(10/4);//在java中结果等于2
		System.out.println(10.0/4);//结果=2.5
		double d = 10/4;//先算出结果等于2
		System.out.println(d);//输出d把2在赋值给double，结果等于2.0

	//例子
		System.out.println(10%7);//结果等于3，%取的是10/7的余数
		System.out.println(25%12);//结果=1
		System.out.println(100%30);//结果=10
		System.out.println(56%17);//结果=5
		System.out.println(-89%15);//结果=-14
		System.out.println(10%-3);//结果=1

关系运算符

//例子
		int a = 10;
		int b = 9;
		System.out.println(a==b);//结果(false假)
		System.out.println(a!=b);//结果(ture真)
		System.out.println(a<b);//结果(false假)
		System.out.println(a>b);//结果(ture真)
		System.out.println(a<=b);//结果(false假)
		System.out.println(a>=b);//结果(ture真)
		boolean flag = a > b;
		System.out.println("flag="+flag);//结果flag=(ture真)

逻辑运算符

短路与(&&) 逻辑与(&) 的使用

//例子		
		int age = 50;
		if(age > 20 && age < 92){
			System.out.println("输出这句话");
		}
		//短路与(&&)规则：当a和b都为(ture真),则结果为(ture真),否则为(false假)
		
		int day = 50;
		if(day > 20 & day < 92){
			System.out.println("继续输出这句话");
		}
		//逻辑与(&)规则：当a和b都为(ture真),则结果为(ture真),否则为(false假)

		/*  &&	和 & 的使用区别
		 * 短路与(&&):如果第一个条件为false，则第二个条件不会判断，最终结果为false(效率高)
		 * 逻辑与(&):不管第一个条件是否为false，第二个条件都要判断，效率低
		 * 在开发中，基本都是使用短路与(&&)，因为效率高
		 */

短路或(||) 逻辑或(|) 的使用

//例子		
		int age = 50;
		if(age > 20 || age < 30){
			System.out.println("输出这句话"); 
		}
		//短路或(||)的规则:a和b中只要有一个为true，结果为true，否则为false
		
		int day = 50;
		if(day > 20 | day < 30){
			System.out.println("继续输出这句话");
		}
		//逻辑或(|)的规则:a和b中只要有一个为true，结果为true，否则为false
		/*  ||	和	|的使用区别
		 * 短路或(||):如果第一个条件为(真)true，则第二个条件不会判断，最终结果为true(效率高)
		 (如果第一个条件为(假)false,则继续判断第二个条件，如果为真结果(真)true)
		 * 逻辑或(|):不管第一个条件是否为(真)true，第二个条件都要判断，效率低
		 * 在开发中，基本都是使用短路或(||)，因为效率高
		 */

取反(!) 逻辑异或(^) 的使用

//例子		
		int a = 10;
		int b = 20;
		if(!(a<b)) {//a<b为真，取反操作为假所以不会输出这句话
			System.out.println("输出这句话");
		}
		System.out.println(60>20);
		System.out.println(!(60>20));
		//取反(!)的规则:如果条件本身成立，则结果为假false，否则为真true
		
		int age = 50;
		int num = 60;
		if((age < 60) ^ (num > 50)) {//(age < 60)为真，(age01 > 50)为真
			System.out.println("输出这句话");//根据逻辑异或(^)的规则所以不会输出这句话
		}
		boolean c = (10>5) ^ (20<30);
		//          a(true)  b(true)
		System.out.println("c="+c);
		//逻辑异或(^)的规则:当a和b不同时结果为真true，否则为假false

赋值运算符

//例子
		int a = 10;
		int b = 20;
		a += b;//是a = a + b;的简写，其他复合运算符的使用是一个道理
		System.out.println(a);
		
		/*赋值运算符的特点
		 * 运算顺序从右往左
		 * 赋值运算符的左边，只能是变量，右边可以是变量，表达式，常量值
		 * 复合赋值运算符会进行类型转换
		 */
		//复合赋值运算符在进行运算的时候会有一个强制转换
		byte c = 2;
		c += 3;//等价 b=(byte)(b+2);
		c++;//b=(byte)(b+1);
		System.out.println(c);

三元运算符

//例子
		int a = 10;
		int b = 20;
		int c = a>b ? a++ : b--;//因为10>20为false(假)使用会执行表达式2,b--
		//  条件表达式   1     2
		System.out.println(c);//先赋值，再自减

		/*三元运算符细节
		 * 表达式1和表达式2要为,可以赋给接收变量的类型(或可以自动转换/强制转换)
		 */
		int s = 5;
		int z = 10;
		//int w = s<z ? 1.1 : 3.4;
		int w = s<z ? (int)1.1 : (int)3.4;
		double q = s<z ? 1.1 : 3.4;
		System.out.println(w);
		System.out.println(q);
		//三元表达式可以转换成if--else语句
		if(s<z) {
			System.out.println(1.1);
		}else {
			System.out.println(3.4);
		}

位运算符

		/*
		 * 安位与   (&): 两位全为1,结果为1
		 * 安位或   (|): 两位有一个为1,结果为1,否则为0
		 * 安位异或(^): 两位一个为0,一个为1,结果为1,否则为0
		 * 安位取反(~): 0>1 , 1>0
		 * 
		 * >>  <<  >>>
		 * 
		 */
		/* 1.先得到2的补码=>00000000 00000000 00000000 00000010
		 *  再得到2的原码=>00000000 00000000 00000000 00000010
		 *  
		 *(计算机运算的时候都是以补码的方式来运算的,
		 *  当我们看运算结果的时候要看它的原码)
		 *  
		 * 2.得到3的补码=>00000000 00000000 00000000 00000011
		 *  再得到3的原码=>00000000 00000000 00000000 00000011
		 *  
		 *  安位&：
		 *       0000000000000 00000000 000 00000010
		 *       00000000 00000000 00000000 00000011
		 *  结果:00000000 00000000 00000000 00000010 补码
		 *  再转成原码:
		 *  00000000 00000000 00000000 00000010
		 */
		
		System.out.println(2&3);//2
		
		/*1.先得到-2的原码=> 10000000 00000000 00000000 00000010
		 *2. -2的 反码 => 11111111 11111111 11111111 11111101
		 *3. 12的 补码 => 11111111 11111111 11111111 11111110
		 *4. ~-2操作=>   00000000 00000000 00000000 00000001
		 *5. 运算后的原码 00000000 00000000 00000000 00000001=>1
		 */
		System.out.println(~-2);//1
		
		/*1.得到2的补码 => 00000000 00000000 00000000 00000010
		 *2. ~2操作 => 11111111 11111111 11111111 11111101
		 *3.运算后的反码 =>11111111 11111111 11111111 11111100  运算后的补码
		 *4.运算后的原码 => 10000000 00000000 00000000 00000011
		 */
		System.out.println(~2);
		
		/* 算数右移 >>: 低位溢出，符号位不变，并用符号位补溢出的高位
		 * 算数左移 <<: 符号位不变，低位补0
		 * 逻辑右移>>>: 低位溢出，高位补零
		 */
		int a = 1>>2;//00000000 00000000 00000000 00000000 (01扔掉)
		//    1 / 2 / 2
		int b = 1<<2;//00000000 00000000 00000000 00000100
		//    1 * 2 * 2 
		System.out.println(a);//0
		System.out.println(b);//4

++（自增）和 - -（自减）

//++的使用：独立使用前++和后++一样
		int i=10;
		i++;//自增  等价于i=i+1  结果=11
		++i;//自增  等价于i=i+1  结果=12
		System.out.println(i);
		/*作为表达式使用
		 * 前++：++i先自增后赋值
		 * 后++：i++先赋值后自增
		 */
		int j = 8;
		int k = ++j;// 先自增j=j+1; 再赋值k=j;
		System.out.println("k="+k+"j="+j);//9  9
		
		int a = 8;
		int b = a++;// 先赋值b=a; 再自增a=a+1;
		System.out.println("a="+a+"b="+b);//9  8
	
		//--的使用，和++同理
		 int c =10;
		 c--; //c=10-1;  c=9;
		 --c;//c=9-1;  c=8;
		 System.out.println(c);//8
		
		 int y = 10;
		 int o = --y;  //y=y-1; k=y;
		 System.out.println("y="+y+"o="+o);//9  9
		 
		 int p = 10;
		 int q = p--;  //q=10; p=10-1;
		 System.out.println("p="+p+"q="+q);//9  10

演示一个接收用户输入

package demo2;

import java.util.Scanner;//表示把java.util下的Scanner类导入

public class day8 {

	public static void main(String[] args) {
		/*演示接收用户的输入：
		 * 先引入Scanner类所在的包
		 * 创建Scanner对象 new一个对象
		 * myScanner 就是 Scanner 对象的名字(这个名字可以是任意的)
		 */
		Scanner myscanner = new Scanner(System.in);
		//接收用户输入，使用相关方法
		System.out.println("请输入名字");
		String name = myscanner.next();//接收用户输入的字符串
		System.out.println("请输入年龄");
		int age = myscanner.nextInt();//接收用户输入的int
		System.out.println("请输入薪水");
		double sal = myscanner.nextDouble();//接收用户输入的double
		System.out.println("人的信息如下");
		System.out.println("名字:"+name+"\n"+"年龄:"+age+"\n"+"薪水:"+sal+"\n");
	}
}