Java时间胶囊-Java基本语法（1）（运算符和流程控制（1））

Java时间胶囊-Java基本语法（1）（运算符和流程控制（1））

运算符

（运算符是一种特殊的符号 用以表示数据的运算 赋值 比较）

• 算术运算符
• 赋值运算符
• 比较运算符（关系运算符）
• 逻辑运算符
• 位运算符（开发中用的比较少 基本很少用 看是看系统源码会出现 明白就行）
• 三元运算符

算术运算符

• %取模（取余）
• ++（自增）（i++是先取i然后++）（++i是直接i+1）
• --（自减）（同++）
• 略

算数运算符注意事项

		int num1 = 12;
		int num2 = 5;
		int result1 = num1 / num2;
		System.out.println(result1);// 2

		double result2 = num1 / num2;
		System.out.println(result2);// 2.0
		// 因为num1 num2的类型是int （num1/num2的结果还是int）所以result = 2.0

		double result3 = (double)num1 / (double)num2;// 可以使用强制转换
		System.out.println(result3);

		double result4 = num1 / num2 + 0.0;// 2.0
		double result5 = num1 / (num2 + 0.0);// 2.4
		// 因为Java程序进行运算时 当容量小的类型和容量大的类型进行运算时 会自动转换成容量大的类型 （多种数据类型混合运算时，各自先转换成容量最大的那一种再做运算）
		// 所以(num2 + 0.0) = double类型 所以当int / double类型时 结果会自动运算为double类型
		System.out.println(result4);
		System.out.println(result5);

取模运算符（%）注意事项

（结果符号 和被模数（（a%b）前面（a）为被模数）的符号相同）（开发中经常用%符号判断能否被除尽的情况）

		int m1 = 12;// 被模数
		int n1 = 5;// 模数
		System.out.println("m1 % n1 = " + m1 % n1);// 2

		int m2 = -12;// 被模数
		int n2 = 5;// 模数
		System.out.println("m2 % n2 = " + m2 % n2);// -2

		int m3 = 12;// 被模数
		int n3 = -5;// 模数
		System.out.println("m3 % n3 = " + m3 % n3);// 2

		int m4 = -12;// 被模数
		int n4 = -5;// 模数
		System.out.println("m4 % n4 = " + m4 % n4);// -2

自增运算符（++/--）注意事项

（++a）先自增1在运算
（a++）先运算后自增1
（自增自减 不会改变变量本身数据类型 效率更高（开发中常用））

		int a1 = 10;
		int b1 = a1++;
        // 先运算 后自增1 就相当于b1 = a1;a1++;
		System.out.println("a1 = " + a1 + "\tb1 = " + b1);// a1 = 11 b1 = 10

		int a2 = 10;
		int b2 = ++a2;
		System.out.println("a2 = " + a2 + "\tb2 = " + b2);// a1 = 11 b1 = 11
        // 注意点
		short s1 = 1;
		// s1 = s1 + 1;// 编译失败 在int范围内 运算也在int空间进行
		// s1 = (int)(s1 + 1);// 编译成功
		s1++;// 自增1（自增自减） 不会改变变量本身数据类型 效率更高（开发中常用）

算术运算符练习

        // 输入一个三位数字 取出百 十 个位
		Scanner input = new Scanner(System.in);	
		System.out.println("Please input number!");
		int number = input.nextInt();
		int best = number / 100;
		int ten = number % 100 / 10;
		int a = number % 10;
		System.out.println("数字为：" + number);
		System.out.println("百位：" + best);
		System.out.println("十位：" + ten);
		System.out.println("个位：" + a);
	}

赋值运算符（=）

支持连续赋值

		int i1 = 10;
		int j1 = 10;

		int i2 i3;
		// 连续赋值
		i2 = j2 = 10;

拓展（+= -= /= *= %= <= >=）

（这样的语法规则 不会改变数据类型）

		int num1 = 10;
		num2 += 2;
		System.out.println(num1);

		int num2 = 12;
		num2 %= 5;
		System.out.println(num2);
		
		short s1 = 10; 
		// s1 = s1 + 2;// 编译失败
		s1 += 2;
		System.out.println(s1);// 可以编译通过 因为+=不会改变变量本身的数据类型

（符合运算符类型在进行运算时 不会改数据类型（应该是强制转换为数据本身的类型 然后进行运算））

比较运算符

（比较运算符的结果都是布尔类型）（eg:4>=3的意思是4>3或者4=3 所以结果是true）
（> < >= <=只能使用在数值类型之间）
（== !=不仅可以使用在数值类型之间 还可以在其他引用类型之间使用）

        Account acct1 = new Account();
        Account acct2 = new Account();
       acct1 == acct2;
       // 这里比较的是两个对象之间的引用 通俗的讲 比较的是这两个引用指向的是不是同一个对象

逻辑运算符

• &逻辑与 |逻辑或 ！逻辑非
• &&短路与 ||短路或 ^短路异或
• （只能适用与布尔类型）

（^）异或类型

异或：当ab相同时false 当ab不相同时true（相同false 不同true）

（&/&&）的区别

		boolean b1 = true;
		b1 = false;
		int num1 = 10;
		if (b1 & (num1++ > 0)) {
			System.out.println("我现在在北京");
		} else {
			System.out.println("我现在在南京");
		}
		System.out.println("num1:" + num1);
		// num1 = 11 (num1++ > 0)执行了

		boolean b2 = true;
		b2 = false;
		int num2 = 10;
		if (b2 && (num1++ > 0)) {
			System.out.println("我现在在北京");
		} else {
			System.out.println("我现在在南京");
		}
		System.out.println("num2:" + num2);
		// num2 = 10 &&是短路与 所以(num1++ > 0)给过滤了 没有执行

• 相同点
  1.&和&&的运算结果相同
  2.当符号左边都是true时 二者都会执行右边的运算

• 不同点
  当符号左边是false时 &会执行符号右边的运算 &&不会执行符号右边的运算

（|/||）的区别

（区别和&/&&的区别相似）

• 相同点
  1.|和||的运算结果相同
  2.当符号左边都是false时 二者都会执行右边的运算

• 不同点
  当符号左边是true时 &会执行符号右边的运算 &&不会执行符号右边的运算

（见名知意 或（逻辑或）和短路或 与（逻辑与）和短路与）

对于开发来讲 推荐使用短路类型

逻辑运算符练习

		boolean x = true;
		boolean y = false;
		short z = 42;
		// if(y == true)
		if ((z++ == 42) && (y = true)) z++;
		if ((x = false) || (++z == 45)) z++;
		System.out.println(z);
		// z = 46

位运算符

（<< / >> / >>>（无符号右移 无符号无左移 因为左边首位是符号位） / & / | / ^）
位运算符操作的都是整形的数据

• <<（左移）
  左移符号的意思是（数字二进制 向左边移动两位 右边空出来的位数都用0来补全）
  左移有限制 当移动后左边首位符号位变化 则错误（物极必反）

3:
0011
3>>2
00移去 11后面两位补全为：1100 == 12

• 结论：
  1.位运算符操作的都是 整形的数据
  2.在一定范围内（有符号位的存在） 每向左移动一位相当于乘以2
  3.在一定范围内 每向右移动一位相当于除以2（右移 每向右边移动 左边空出来的位置（原来最高位是0（正数） 用0补）（最高位是1（负数） 用1补（都补1））可以记为：符号位不变 左边补上符号位）（负数也相同）
  （负数进行位运算时 要先转换为补码的形式（因为计算机在底层存放二进制数值 都是以二进制补码的形式存放 而正数的原码和反码补码相同））

• （>>>）（无符号右移）（没有无符号左移 因为有符号位的存在）
  不管是正数还是负数 向右移动后 左边空缺的位置都用0补齐
  如果一个数字是负数 向右边移动一位就能立马变正数

位运算符中的&|^运算

（还是利用底层二进制来进行运算）

     12:   0000 1100
&   5:    0000 0101
*****************************
            0000 0100

=    4:   0000 0100

|和^的运算方式和&相同

~（取反运算符）（包括符号位在内 0变1 1变0）

• 正数取反 各二进制按照补码各位取反（正数取反必是负数 正数在补码取反后 -1（因为负数的原码 = 反码 + 1）然后取反（因为要化为负数的原码） 最后转化为十进制然后添加负号就行）
• 负数取反 各二进制按照补码形式取反

位运算符的练习（练习两个数值的交换的三种方法）

		int num1 = 10;
		int num2 = 20;
		
		// // 第一种方法 冒泡排序
		// int temp = num1;
		// num1 = num2;
		// num2 = temp;
		// System.out.println(num1 + "\t" + num2);

		// // 第二种方法 累加法
		// num1 = num1 + num2;
		// num2 = num1 - num2;
		// num1 = num1 - num2;
		// System.out.println(num1 + "\t" + num2);
		
		// 第三种方法 位运算符交换法
		// m ^ n = k; k ^ m = n;
		num1 = num1 ^ num2;
		num2 = num1 ^ num2;
		num1 = num1 ^ num2;
		System.out.println(num1 + "\t" + num2);
       // 位运算符 只能运算数值类型

三元运算符

(条件表达式):表达式1:表达式2 （条件表达式的结果是boolean类型 条件表达式 = true运行表达式1 条件表达式 = false运表达式2）（隐形条件：表达式1和2 要求是能统一为一个类型）（凡是可以使用三元运算符的地方都可以改为if-else）
三元运算符的嵌套
(m > n) ? "m" : (m == n) ? "m == n" : "n"

---

三元运算符的练习（获取三个数中间的最大值）

		int max1 = (n1 > n2)? n1 : n2;
		int max2 = (max1 > n3)? max1 : n3;
		System.out.println(max2);

		int max3 = (((n1 > n2)? n1 : n2) > n3)? max1 : n3;
		System.out.println(max3);
		// 可读性差 不建议这样写 很难改 写代码不能一味追求美观（需要效率高）

运算符的优先级

其实想早运算的添加（）就行了... .. . 因为所有运算不能在一行中使用 这样可读性太差了

程序流程控制

（整体是顺序结构（顺序的分支是-循环结构-分支结构））

顺序结构

从上到下一路直行

分支结构

• if-else（选一 无论多少分支 都是多选一）（分支结构中的条件判断结构）
• switch-case

标签：Java,num1,int,胶囊,System,运算符,println,out
来源： https://www.cnblogs.com/weinen/p/14053611.html