Java基础系列6-Java的运算符

àì夳堔傛蜴生んèń 2022-09-04 02:48 113阅读 0赞

### 文章目录 ###

*  一.运算符概述
 *   *  1.1 算术运算符
     *  1.2 赋值运算符
     *  1.3 关系运算符（比较运算符）
     *  1.4 逻辑运算符
     *  1.5 三元运算符
 *  参考:

# 一.运算符概述 #

对常量和变量进行操作的符号称为运算符。

用运算符把常量或者变量连接起来符号java语法的式子就可以称为表达式。  
不同运算符连接的式子体现的是不同类型的表达式。  
定义两个int类型的变量a、b，做加法(a + b)

常用运算符:

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

## 1.1 算术运算符 ##

算数运算符：  
\+、-、\*、/、%、++、–

代码1:

package Java_study;
    
    public class yunsuanfu {
    	public static void main(String[] args) {
    	//定义两个int类型的变量
    	int a = 5;
    	int b = 3;
    	//8
    	System.out.println(a + b);
        //2
    	System.out.println(a - b);
    	//15
    	System.out.println(a * b);
    	//求商, 5/3=1.66(int取整数)=1
    	System.out.println(a / b);
    	// 求余数 5%3=2
    	System.out.println(a % b);
    	System.out.println("----------");
    	// 整数计算，默认为整数 int类型 5/4=1
    	System.out.println(5 / 4);
    	//带小数计算，默认为浮点 double 类型 5 /4 = 1.25
    	System.out.println(5.0 / 4);
    	//带小数计算，默认为浮点 double 类型 5 /4.0 = 1.25
    	System.out.println(5 / 4.0);
    	}
    }

测试记录1:

8
    2
    15
    1
    2
    ----------
    1
    1.25
    1.25

字符和字符串参与加法运算【‘a’+10=57】  
字符参与运算其实是拿该字符对应的数值来操作:

1.  ‘a’ 97
2.  ‘A’ 65
3.  ‘0’ 48

字符串参与运算这里其实做的不是加法运算，而是字符串拼接。  
字符串和其他类型的数据做拼接，结果是字符串类型的。

代码2:

package Java_study;
    
    public class yunsuan2 {
    	public static void main(String[] args) {
    		//定义两个变量，一个int类型，一个char类型
    		int a = 10;
    		char ch = 'a';
    		// 'a' + 10 = 97 + 10 = 107
    		System.out.println(a + ch);
    		System.out.println("----------");
    		
    		//字符串做加法
    		//helloworld
    		System.out.println("hello" + "world" );
    		//hello10
    		System.out.println("hello" + 10);
    		//hello1020
    		System.out.println("hello" + 10 +20);
    		//30hello
    		System.out.println(10 + 20 + "hello");
    	}
    
    }

测试记录:

107
    ----------
    helloworld
    hello10
    hello1020
    30hello

自增自减运算符【i++ 与 ++i】

1.  \++,–运算符：对变量做加1或者减1的操作。
2.  \++或者–既可以放在变量的后面，也可以放在变量的前面。
3.  单独使用的时候，++或者–无论是放在变量的前面还是后面，结果是一样的。
4.  参与操作的时候：  
    1)如果 ++ 或者 - - 在变量的后面，先拿变量参与操作，后变量做++或者- -  
    2)如果 ++ 或者 - - 在变量的前面，先变量做++或者- -，后拿变量参与操作

代码3:

package Java_study;
    
    public class yunsuan3 {
    	public static void main(String[] args) {
    		//定义一个int类型的变量
    		int i = 10;
    		System.out.println("i:" + i);
    		
    		// i = i +1 = 10 +1 = 11
    		int b = ++i;
    		System.out.println("i:" + i);
    		System.out.println("b:" + b);
    		
    		// b = i = 11
    		// (然后 i= i+ 1 = 12)
    		b = i++;
    		// i = 12
    		System.out.println("i:" + i);
    		// b = 11
    		System.out.println("b:" + b);
    	}
    
    }

测试记录:

i:10
    i:11
    b:11
    i:12
    b:11

## 1.2 赋值运算符 ##

1.  基本的赋值运算符：=
2.  扩展的赋值运算符：+=,-=,\*=,/=,%=  
    \+=: a+=20;相当于a = (a的数据类型)(a + 20);

代码:

package Java_study;
    
    public class yunsuan4 {
    	public static void main(String[] args) {
    		//定义变量
    		int a = 10; // 把10赋值给int类型的变量a
    		System.out.println("a:" + a);
    		
    		//扩展的赋值运算符: +=
    		//把运算符左边的数据和右边的数据进行运算，然后把结果赋值给左边
    		// a = a +20
    		a +=20;
    		System.out.println("a:" + a);
    		
    		// short s = 1;
    		// s = s + 1;
    		
    		//扩展的赋值运算符隐含了强制类型转换
    		//a += 20 等价于 a = (a的数据类型)(a+20)
    		short s = 1;
    		s += 1;
    		System.out.println("s:" + s);
     	}
    
    }

测试记录:

a:10
    a:30
    s:2

## 1.3 关系运算符（比较运算符） ##

关系运算符包含以下内容:  
==、!=、>、>=、<、<=

关系运算符的结果都是boolean型，也就是要么是true，要么是false。

注意事项:  
关系运算符“==”不能误写成“=”。

代码:

package Java_study;
    
    public class yunsuan5 {
    	public static void main(String[] args) {
    		//定义三个变量
    		int a = 10;
    		int b = 20;
    		int c = 10;
    		
    		//==
    		System.out.println("------[==]------");
    		// a == b : false (10=20)
    		System.out.print("a ==b:");
    		System.out.println(a == b);
    		// a == c : true (10=10)
    		System.out.print("a == c:");
    		System.out.println(a == c);
    		
    		//!=
    		System.out.println("----[!=]------");
    		// a != b : true (10!=20)
    		System.out.print("a != b:");
    		System.out.println(a != b);
    		// a != c :false (10!=10)
    		System.out.print("a != c:");
    		System.out.println(a != c);
    		
    		//>
    		System.out.println("-----[>]------");
    		//a > b: false (10>20)
    		System.out.print("a > b:");
    		System.out.println(a > b);
    		// a > c false (10>10)
    		System.out.print("a > c:");
    		System.out.println(a > c);
    		
    		//>=
    		System.out.println("------[>=]------");
    		// a >= b: false (10>20)
    		System.out.print("a >= b:");
    		System.out.println(a >= b);
    		// a >= c :true (10>=10)
    		System.out.print("a >= c:");
    		System.out.println(a >= c);
    		
    		// == 与 =
    		System.out.println("------[==与=]------");
    	    // a == b: false (10=10)
    		System.out.print("a == b:");
    		System.out.println(a == b);
    		// a = b : 20 (先把b的值付给了a，再吧a作为结果输出)
    		System.out.print("a = b:");
    		System.out.println(a = b);
    	}
    
    }

测试记录:

------[==]------
    a ==b:false
    a == c:true
    ----[!=]------
    a != b:true
    a != c:false
    -----[>]------
    a > b:false
    a > c:false
    ------[>=]------
    a >= b:false
    a >= c:true
    ------[==与=]------
    a == b:false
    a = b:20

## 1.4 逻辑运算符 ##

逻辑运算符用于连接关系表达式，在Java中不可以写成3<x<6，应该写成x>3 && x<6 。

逻辑运算符：  
与【&】【&&】、或【||】、非【！】

结论：

1.  与【&】【&&】：有false则false。  
    1)&　不管前面的条件是否正确，后面都执行  
    2)&&　前面条件正确时，才执行后面，不正确时，就不执行，就效率而言，这个更好
2.  或【||】：有true则true。
3.  非【！】：非false则true，非true则false。  
    特点：偶数个【！】不改变本身。

代码:

package Java_study;
    
    public class yunsuanfu6 {
    	public static void main(String[] args) {
    		//定义变量
    		int a = 3;
    		int b = 4;
    		int c = 5;
    		
    		//&&逻辑与
    		System.out.println("-----[&&逻辑与 满足全部条件]------");
    		//(3 > 4) && (3 > 5) ==> false && false :false
    		System.out.print("(3 > 4) && (3 > 5) ==> false && false :false");
    		System.out.println((a > b) && (a > c));
    		//(3 < 4) && (3 > 5) ==> true && false : false
            System.out.print("(3 < 4) && (3 > 5) ==> true && false : ");
            System.out.println((a < b) && (a > c)); //true && false
            //(3 > 4) && (3 < 5) ==> false && true : false
            System.out.print("(3 > 4) && (3 < 5) ==> false && true : ");
            System.out.println((a > b) && (a < c)); //false && true
            //(3 < 4) && (3 < 5): ==> true && true : true
            System.out.print("(3 < 4) && (3 < 5): ==> true && true : ");
            System.out.println((a < b) && (a < c)); //true && true
    
    
            //||逻辑或
            System.out.println("-----【||逻辑或 满足任一条件】-------");
            //(3 > 4) || (3 > 5) ==> false || false : false
            System.out.print("(3 > 4) || (3 > 5) ==> false || false : ");
            System.out.println((a > b) || (a > c));
            //(3 < 4) || (3 > 5) ==> true || false : true
            System.out.print("(3 < 4) || (3 > 5) ==> true || false : ");
            System.out.println((a < b) || (a > c));
            //(3 > 4) || (3 < 5) ==> false || true : true
            System.out.print("(3 > 4) || (3 < 5) ==> false || true : ");
            System.out.println((a > b) || (a < c));
            //(3 < 4) || (3 < 5) ==> true || true : true
            System.out.print("(3 < 4) || (3 < 5) ==> true || true : ");
            System.out.println((a < b) || (a < c));
    
    
            //!逻辑非
            System.out.println("-----【!逻辑非 取反】-------");
            //(3 > 4) : false
            System.out.print("(3 > 4) : ");
            System.out.println((a > b));
            //!(3 > 4) ==> ! false : true
            System.out.print("!(3 > 4) ==> ! false : ");
            System.out.println(!(a > b));
            //!!(3 > 4)  ==> !! false : false
            System.out.print("!!(3 > 4)  ==> !! false : ");
            System.out.println(!!(a > b));
    	}
    
    }

测试记录:

-----[&&逻辑与 满足全部条件]------
    (3 > 4) && (3 > 5) ==> false && false :falsefalse
    (3 < 4) && (3 > 5) ==> true && false : false
    (3 > 4) && (3 < 5) ==> false && true : false
    (3 < 4) && (3 < 5): ==> true && true : true
    -----【||逻辑或 满足任一条件】-------
    (3 > 4) || (3 > 5) ==> false || false : false
    (3 < 4) || (3 > 5) ==> true || false : true
    (3 > 4) || (3 < 5) ==> false || true : true
    (3 < 4) || (3 < 5) ==> true || true : true
    -----【!逻辑非 取反】-------
    (3 > 4) : false
    !(3 > 4) ==> ! false : true
    !!(3 > 4)  ==> !! false : false

## 1.5 三元运算符 ##

格式:  
(关系表达式)?表达式1：表达式2；  
如果条件为true，运算后的结果是表达式1；  
如果条件为false，运算后的结果是表达式2；

代码:

package Java_study;
    
    public class yunsuanfu7 {
    	public static void main(String[] args) {
    		// 定义两个变量
    		int a = 10;
    		int b = 20;
    		
    		// (10>20) => false => 表达式2 => b => 20
    		int c = (a > b) ? a : b;
    		//c:20
    		System.out.println("c:" + c);
    		
            
    		a = 10;
    		b = 10;
    		// ( 10 == 10) => true => 表达式1 => true
    		boolean flag = ( a == b) ? true : false;
    		//flag:true
    		System.out.println("flag:" + flag);
    		
    	}
    
    }

测试记录:

c:20
    flag:true

# 参考: #

1.  https://blog.csdn.net/qq\_43529621/article/details/113182363