Java教程

JAVA程序入门--基础知识(运算符)

本文主要是介绍JAVA程序入门--基础知识(运算符),对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

文章目录

  • 前言
  • 一、运算符
    • 1、算数运算符
      • 1.1、案例
    • 2、自增自减运算符
      • 2.1、案例一(认识自增自减法)
      • 2.2、案例二(自增自减法运算规则)
      • 2.3、案例三(自增自减综合练习)
        • 2.3.1、增强练习(根据上述代码,进行如下练习)
        • 2.3.2、增强结果
    • 3、关系运算符
      • 3.1、案例一
    • 4、逻辑运算符
      • 4.1、简单逻辑梳理
      • 4.2、案例一
    • 5、赋值运算符
      • 5.1、案例一
    • 6、三目运算符
      • 6.1、案例一(小杨同学找教室)
      • 6.2、案例二(小杨同学找教室-进阶版)
    • 7、加号(+)的使用
      • 7.1、案例一(测试+号的用途)
    • 8、扩展练习


前言

   前面我们了解到了基本的 《运算规则》 当然在运算的过程当中也少不了我们的运算符,有我们熟悉的“+”,“-”,“*”,“/”。以及Java语言的一些特殊得运算符,比如自增,自减、逻辑运算符等,这里我就不多啰嗦了,跟着笔者一起往下看吧~~

提示:以下是本篇文章正文内容,下面案例可供参考

一、运算符


1、算数运算符

相信大家对算数运算符应该都很了解,无非就是加“减乘除以及取余数”


操作符描述例子
"+"加法···相加运算符、表示两侧的值相加10 + 20 等于 30
"-"减法···左操作数减去右操作数30 - 20 等于 10
"*"乘法···相乘操作符、表示两侧的值相乘10 * 20 等于 200
"/"除法···左操作数整除右操作数20 / 10 等于 2
"%"取余···左操作数除以右操作数的余数20 % 10 等于 0


1.1、案例

(1)声明三个int类型的变量,名字分别为(a、b、c);
(2)运用三个数练习加减乘除、取余的练习操作

注意: “+”加号可以用来加法运算,也可以用来做字符串的拼接

public static void main(String[] args) {
	//1.创建三个变量,名字分别为a、b、c
	int a = 10;
	int b = 20;
	int c = 25;
	//2.加减乘除、取余运算
	//2.1.加法运算,注意这里+可以用来加法运算,也可以拼接。
	System.out.println("+是加法运算:" + (a + b));//30
	
	//2.2.减法运算
	System.out.println("-是减法运算:" + (b - a));//10
	
	//2.3.乘法运算
	System.out.println("*是乘法运算:" + (a * b));//2000
		
	//2.4.除法运算
	System.out.println("/是除法运算:" + (b / a));//2
		
	/*
	* 2.5.取余运算、也叫求模
	* 	   例如:
	* 			20 / 10 = 2 ...... 0  余数是 0
	* 			10 / 20 = 0 ...... 10 余数是 10
	* 			25 / 10 = 2 ...... 5  余数是 5 
	*/
	System.out.println("%数余数运算:" + (b % a));//0
	System.out.println("%数余数运算:" + (a % b));//10
	System.out.println("%数余数运算:" + (c % a));//5		
}

“%”的用法:
   用于判断是一个奇数还是偶数,或者是否可以被整除

(1)整数值 %2 结果为零,则这个数一定是偶数
(2)整数值 %2 结果为1, 则这个数一定是奇数
(3)整数值 %n 结果为0,则这个数一定能被n整除



2、自增自减运算符

  自增自减运算符存在于C/C++/C#/Java/等高级语言中,它的作用是在运算结束前(前置自增自减运算符)或后(后置自增自减运算符)将变量的值加(或减)1。后面我们会去具体了解

注意:
   (1)“++a” 前置自增,会先自增在输出结果
   (2)“--a”   前置自减,会先自减再输出结果
   (3)“a++” 后置自增,会先输出结果再自增
   (4)“a--”   后置自减,会先输出结果再自减

操作符描述例子
"++"自增···操作的值增加120++ 或 ++20 等于 21
"--"自减···操作的值减少120-- 或 --20 等于 19


2.1、案例一(认识自增自减法)

(1)声明四个int类型的变量,名字分别为(d、e、f、g);
(2)认识前置自增和后置自增
(3)认识前置自减和后置自减

public static void main(String[] args) {
	//1.声明四个int类型的变量,名字分别为d、e、f、g
	int d = 10;
	int e = 10;
	int f = 10;
	int g = 10;
	//2.认识前置自增和后置自增
	//2.1. 前置自增,表示如果++符号出现在前面,就先自增再输出结果
	System.out.println("前置自增:" + (++d));//打印结果为:11,先为d自增1(10+1=11)然后执行打印所以结果时11
		
	//2.2. 后置自增,表示如果++符号出现在后面,就先输出结果再自增
	System.out.println("后置自增:" + (e++));//打印结果为:10,先输出e,e此时为10,然后再执行++自增1,此时e为11,我们再打印查看结果
	System.out.println(e);//打印结果为:11
		
	//3.认识前置自减和后置自减
	//3.1. 前置自减,表示如果--符号出现在前面,就先自减再输出结果
	System.out.println("前置自减:" + (--f));//打印结果为:9,先为f自减1(10-1=9)然后执行打印所以结果为9
	
	//3.2. 后置自减,表示如果--符号出现在后面,就先输出结果再自减
	System.out.println("后置自增:" + (g--));//打印结果为:10,先输出g,g此时为10,然后再执行--自增1,此时g为9,我们再打印查看结果
	System.out.println(g);//打印结果为:9		
}


2.2、案例二(自增自减法运算规则)

(1)声明两个int类型的变量(h,i)
(2)使用乘法和自增运算,并声明x,y接收结果值

注意:
   自增自减的优先级高于四则运算(前面我们将的算数运算)
   前置自增自减法(++a,--a): 先进行自增或者自减运算,再进行表达式运算;
   后缀自增自减法(a++,a--): 先进行表达式运算,再进行自增或者自减运算;   

public static void main(String[] args) {
	//1.声明两个int类型的变量(h,i)
	int h=5;
	int i=5;
	
	//2.使用乘法和自增运算,并声明x,y接收结果值
	int x=2*++h;//先进行自增,然后再进行表达式运算
	int y=2*i++;//先进行表达式运算,然后再自增
	
	//3.打印结果
	System.out.println(x);//12
	System.out.println(y);//10
}


2.3、案例三(自增自减综合练习)

注意(对自增自减我们要谨记两点):
   (1)符号在前(前置),先变化再使用;
   (2)符号在后(后置),先使用后变化;

public static void main(String[] args) {		
	//1.自增
	int a=1;
	System.out.println("后置自增:a=" + (a++));//后置自增,先运算再变化,所以这里输出还是1
	System.out.println("后置自增后的:a=" + a);//运算完就会发生变化,此时a是2
	
	int b=1;
	System.out.println("前置自增:b=" + (++b));//前置自增,先变化再运算。所以这里输出的是自增后的结果2
	System.out.println("前置自增后的:b=" + b);//运算前就会发生自增变化,所以此时的b还是2
		
	//2.自减
	int c=1;
	System.out.println("后置自减:c=" + (c--));//后置自减,先运算再变化,所以这里输出的依然是1
	System.out.println("后置自减后的:c=" + c);//运算完后才会发生改变,所以此时的c是0
	
	int d=1;
	System.out.println("前置自减:d=" + (--d));//前置自减,先变化再运算,所以这里输出的是自减后的结果0
	System.out.println("前置自减后的:d=" + d);//运算前就会发生自减变化,所以此时的d还是0
}


2.3.1、增强练习(根据上述代码,进行如下练习)

public static void main(String[] args) {		
	
	...... 这里是案例三的代码
	
	//增强练习
	/**
	 * 增强一:自增,思考如下的运算结果。a目前是几,b目前又是几,最后的运算结果是多少?
	 */
	System.out.println(++a+a+b++);//???
	/**
	 * 增强二:自减,思考如下的运算结果。三个c分别是几,最后的运算结果是多少?
	 */
	System.out.println(--c-c-c--);//???
}


2.3.2、增强结果

//增强练习
/**
 * 增强一:自增,思考如下的运算结果。a目前是几,b目前又是几,最后的运算结果是多少?
 */
System.out.println(a);//案例三,最终a得值为2
System.out.println(b);//案例三,最终b得值也为2
System.out.println(++a+a+b++);//???
System.out.println(b);
/*
 * 增强一分析:
 * 	   1.在案例三的练习中,最后a的值是2,b是的值也是2。所以此时增强一运算前的a=2,b=2
 * 	   2.在运算的过程中,加法运算所以我们从左到右看:
 * 	  	 >先是前置自增++a,前置的规则是先变化再运算,所以此时的a就都是3,此时的公式就是:3+3+b++
 * 		 >随后是后置的自增运算b++,后置的规则是先运算再变化,所以在运算的时候b此时的值依然是2,此时的公式就是3+3+2
 * 		 >最终的运算结果就是8
 * 注意,因b是后置运算,所以经过运算后b最终的值是3;
 */
		
		
/**
 * 增强二:自减,思考如下的运算结果。三个c分别是几,最后的运算结果是多少?
 */
System.out.println(c);//案例三,最终c的值为0
System.out.println(--c-c-c--);//???
System.out.println(c);
/*
 * 增强二分析:
 * 		1.再看案例三的练习中,最后c的值是0,所以在增强二运算前此时c=0
 * 		2.减法运算还是从左往右我们看一下
 * 		  >先是一个前置自减--c,前置的规则是先变化再运算,所以此时的c就都是-1,此时的公式就是(-1 减 -1 减 -1--)
 * 		  >随后是一个后置的自减运算c--,后置的规则是先运算再变化,所以在运算的时候c的值依然是-1,此时的公式就是(-1 减 -1 减 -1)
 * 		  >因为我们是负数在运算的过程中呢,可以看到(-1 减 -1)负负得正,此时运算公式就变成了(-1 + 1)所以运算结果最后是0
 * 		  >然后就是(0 减 -1)依然是负负得正,此时运算公式就变成了(0 + 1)
 * 		  >最终我们得到得运算结果是1
 * 注意:因c最后是后置运算,所以经过运算后c得值是-2;
 */


3、关系运算符

运算符描述例子
"=="获取两个操作数的值是否相等,如果相等则条件成立,即为真(100 == 200)为假
"!="获取两个操作数的值是否相等,如果值不相等则条件成立,即为真(100 != 200)为真
">"检查左操作数的值是否大于右操作数,如果是,那么条件为真(100 > 200)为假
"<"检查左操作数的值是否小于右操作数,如果是,那么条件为真(100 < 200)为真
">="检查左操作数的值是否大于或等于右操作数,如果是,那么条件为真(100 >= 200)为假
"<="检查左操作数的值是否小于或等于右操作数,如果是,那么条件为真(100 <= 200)为假


3.1、案例一

1.分别声明两个int类型的变量;
2.使用关系运算符,对操作数进行对比;

注意:false代表假,true代表真;

public static void main(String[] args) {	
	//1.分别声明两个int类型的变量
	int a = 10;
	int b = 20;
		
	//2.使用关系运算符,对操作数进行对比
	/*
	 * 2.1.“==” -- 等于
	 * 	   >等与则返回true,不等于则返回false
	 */
	System.out.println("a是否等于b: " + (a == b));//打印结果为:false,因为10不等于20,结果为假,返回false;
		
	/*
	 * 2.2.“!=” -- 不等于
	 *     >!表示非,等于则为false,不等于则为true
	 */
	System.out.println("a是否不等b: " + (a != b));//打印结果为:true,因为10不等于20,结果为真,返回true;
	
	/*
	 * 2.3.">" -- 大于
	 *	   >大于则返回true,小于则返回false
	 */
	System.out.println("a是否大于b: " + (a > b));//打印结果为:false,因为10不大于20,结果为假,返回false
		
	/*
	 * 2.4.">" -- 小于
	 *     >小于则返回true,大于则返回false
	 */
	System.out.println("a是否小于b: " + (a < b));//打印结果为:true,因为10小于20,结果为真,返回true
		
	/*
	 * 2.5.">=" -- 大于等于
	 *     >大于等于则返回true,小于则返回false
	 */
	System.out.println("a是否大于等于b: " + (a >= b));//打印结果为:false,因为10不大于也不等于20,结果为假,返回false
		
	/*
	 * 2.5."<=" -- 大于等于
	 *     >小于等于则返回true,大于则返回false
	 */
	System.out.println("a是否小于等于b: " + (a <= b));//打印结果为:false,因为10小于等于20,结果为假,返回true
}


4、逻辑运算符

操作符描述例子
"&&"称为逻辑与运算符,当且仅当两个操作数都为真,条件才为真。((1 == 1) && (1 == 2))为假
"||"称为逻辑或运算符,如果任意两个操作数任意一个为真,条件为真。((1 == 1) || (1 == 2))为真
"!"称为逻辑非运算符,用来反转操作数的逻辑状态。
如果条件为true,则逻辑非运算符得到的是false,
如果条件为false,则逻辑非运算符得到的是true。
!((1 == 1) && (1 == 2))为真

逻辑与、逻辑非均有短路(逻辑运算符当能得到结果时,就不会再继续运算右边的代码,以节省空间以及一定的性能)效果:
   "&&" 左边操作数(表达式1)如果是false,右边不会执行
   "||" 左边操作数(表达式1)如果是true,右边不会执行



4.1、简单逻辑梳理

逻辑与的理解:(我请你吃饭 && 我请你唱歌)
  其实很好理解,我们可以理解为我们生活中的"并且"关系,比如吃饭唱歌,我请你吃饭并且请你唱歌。从字面我们可以看出来,只有我满足了并且的所有关系,我才不算食言,结果才为真(true),反则只要有一条没满足,我就算食言了。结果就为假(false)。


逻辑或的理解:(我请你吃饭 || 我请你唱歌)
  其实也很好理解,我们可以理解为我们生活中的"或者"关系,还是比如吃饭唱歌,我请你吃饭或者我请你唱歌。从字面意思我们可以看的出来,总共有三种可能,(1)我是要请你吃饭。(2)我请你唱歌。(3)我即请你吃饭,又请你唱歌。只要我满足其中一条关系,我就不算食言,结果就为真(true)。如果我即没请你吃饭,又没带你去唱歌,反而带你去图书馆了。只有没满足逻辑或中的任何一条关系,我就算食言了,结果就为假(false)。

总结:
  假如判断A && B,A如果是false,B无论是false,还是true,结果均为false。
  加入判断A || B,A如果是true,B无论是false,还是true,结果均为true。



4.2、案例一

(1)声明三个int类型的变量
(2)练习逻辑运算符的使用

public static void main(String[] args) {	
	//1.声明三个int类型的变量
	int a = 50;
	int b = 40;
	int c = 30;
		
	//2.练习逻辑运算符的使用
	/*
	 * 2.1.逻辑与练习
	 * 	   >必须满足"&&"两侧所有判断的条件,结果才为true,否则为false
	 */
	System.out.println("a大于b并且b大于c: " + (a > b && b > c));//打印结果为:true,(50 > 40 && 40 > 30),可以看到"&&"两侧的判断均为true,所以结果也为true
	System.out.println("a大于b并且b小于c: " + (a > b && b < c));//打印结果为:false,(50 > 40 && 40 < 30),可以看到"&&"右侧的判断为false,所以结果为false
		
	/*
	 * 2.2.逻辑或练习
	 * 	   >只有"||"两侧所有的判断条件都不成立,结果才为false,否则为true
	 */
	System.out.println("a大于b或者b小于c: " + (a > b && b < c));//打印结果为:true,(50 > 40 && 40 < 30),可以看到"||"左侧的判断为true,由于逻辑或的短路效应,他不会再判断后面的条件,直接就会返回true
	System.out.println("a小于b或者b小于c: " + (a < b && b < c));//打印结果为:false,(50 < 40 && 40 < 30),可以看到"||"两侧的判断均为false,所以结果为false
	
	/*
	 * 2.3."!"表示非,就是不的意思,取反,!true = false\!false = true
	 */
	System.out.println(!true);//打印结果为false,因为我们对true进行了取反
	System.out.println(!false);//打印结果为true,因为我们对false进行了取反
		
	/**
	 * "&&"左侧的判断(50>40)结果为true,右侧的判断(40<30)结果应为false,
	 * 但是我们对其进行了取反,右侧就也变成了true,此时左右两侧均为true。所以我们得到的最终结果就为true
	 */
	System.out.println(a > b && !(b < c));//打印结果为true,公式为:true && !false = true
		
	/**
	 * "||"左侧的判断(50<40)结果应为false,但是我们对左侧的结果进行了取反,此时左侧为true
	 * 	   因为"||"的短路效应,前面只要出现一个true,就不会进行下面的判断了,所以结果为true
	 */
	System.out.println(!(a < b) || b < c);//答应结果为true,判断公式为:!false || false = true

}


5、赋值运算符

操作符描述例子
"="简单的赋值运算符,将右操作数的值赋值给左侧操作数C = A + B将把A + B得到的值赋值给C
"+="加和赋值操作符,它把左操作数和右操作数相加赋值给左操作数C += A 等价于 C = C + A
"-="减和赋值操作符,它把左操作数和右操作数相减赋值给左操作数C -= A 等价于 C = C - A
"*="乘和赋值操作符,它把左操作数和右操作数相乘赋值给左操作数C *= A 等价于 C = C * A
"/="除和赋值操作符,它把左操作数和右操作数相除赋值给左操作数C /= A 等价于 C = C / A


5.1、案例一

(1)声明三个int类型的变量
(2)练习赋值运算符

public static void main(String[] args) {
	//1.声明三个int类型的变量
	int a = 10;
	int b = 20;
	int c = 0;
		
	//2.练习赋值运算符
	//2.1.“=” 赋值操作符
	c = a + b;
	System.out.println("a+b=" + c);//打印结果为30
		
	//2.2.“+=” 赋值操作符
	System.out.println("目前c=" + c);
	c += a;
	System.out.println("c+a=" + c);//打印结果为40
		
	//2.3.“-=” 赋值操作符
	System.out.println("目前c=" + c);
	c -= a;
	System.out.println("c-a=" + c);//打印结果为30

	//2.4.“*=” 赋值操作符
	System.out.println("目前c=" + c);
	c *= a;
	System.out.println("c*a=" + c);//打印结果为300

	//2.5.“/=” 赋值操作符
	System.out.println("目前c=" + c);
	c /= a;
	System.out.println("c/a=" + c);//打印结果为30
}

感觉这个应该都可以理解吧,其实和前面的加减乘除都一样,只不过简写了



6、三目运算符

如果表达式结果为true则返回值1,否则返回值2

	格式:
		布尔表达式 ? 表达式1 : 表达式2


6.1、案例一(小杨同学找教室)

  小杨同学上学分班,A班 : B班(分数在200以上包括200为A班,其余为B班)
(1)告诉小杨输入总分数,并接收小明输入的总分数。
(2)通过接收的分数判断小杨同学分到的班级
  (2.1)如果大于或等于200(true)。表示他是A班的学生。
  (2.2)如果不大于或等于200(false)。表示他是B班的学生。

这里我们会用到Scanner类,如果有不了解的可以去看笔者前面写的内容《输入个人信息、计算圆的面积、变量交换》

public static void main(String[] args) {
	//1.告诉小杨输入总分数,并接收小杨输入的总分数。
	//1.1.告诉小杨输入总分数
	System.out.println("请输入您的您的总分数:");
	//1.2.接收小杨输入的总分数
	int xiaoYang = new Scanner(System.in).nextInt();
		
	//2.判断小杨总分数是否大于等于200,如果是则为A班学生
	String SchoolClass = (xiaoYang >= 200) ? "A班级" : "B班级";
		
	//3.告诉小样分到的班级
	System.out.println("小杨同学,您的班级在:" + SchoolClass);
}


6.2、案例二(小杨同学找教室-进阶版)

  小杨同学升学了,又要分班,现在分为S班、A班 、 B班、C班
(1)告诉小杨输入总分数,并接收小明输入的总分数。
(2)通过接收的分数判断小杨同学分到的班级
  (2.1)如果大于或等于700。表示他是S班的学生。
  (2.2)如果大于等于400但小于700。表示他是A班的学生。
  (2.3)如果大于等于200但小于400。表示他是B班的学生。
  (2.4)其余学生均为C班。

希望各位读者,可以试着自己写一下。如果写不出来再去看下面的代码分析逻辑。锻炼各位的自己梳理逻辑的能力。大佬忽略哈哈~~

public static void main(String[] args) {
	//1.告诉小杨输入总分数,并接收小杨输入的总分数。
	//1.1.告诉小杨输入总分数
	System.out.println("请输入您的您的总分数:");
	//1.2.接收小杨输入的总分数
	int xiaoYang = new Scanner(System.in).nextInt();
		
	//2.判断小杨是否哪个班的同学
	String SchoolClass = (xiaoYang >= 400) ? (xiaoYang >= 700 ? "S班级" : "A班级") : (xiaoYang >= 200 ? "B班级" : "C班级");
		
	//3.告诉小样分到的班级
	System.out.println("小杨同学,您的班级在:" + SchoolClass);
}


7、加号(+)的使用

  加号可以做加法运算(要求两边都得是数值),也可以作为拼接符来使用(只要两边有一个是字符串)

7.1、案例一(测试+号的用途)

public static void main(String[] args) {
	//1.加号的两边都是数字,加号会执行加法运算
	System.out.println(18 + 5);//打印结果为23,数值与数值之间的+号表示进行加法运算
		
	//2.注意char类型底层也是数字
	System.out.println('A' + 1);//打印结果为:66 ,A在char中的表示的数为65。所以这里不会作为拼接而是转换为65进行值与值之间的加法运算
		
	//3.加号可以做为拼接符,将任意的数据和字符串拼接,加号两边只要有一个字符串,就作为拼接符使用
	System.out.println("1" + 1);//因1用双引号包裹,底层会认为是字符串,此时+号就作为拼接符来使用了
		
	//4.输出个人信息
	String name = "小杨";
	int age = 18;
	String salary = "20000";
	//name芳龄age,竟然高薪如此,月入salary
	System.out.println("姓名:"+ name + "-芳龄:" + age + "-月入:" + salary);
}


8、扩展练习

使用三目表达式判断用户输入的最大值
(1)提醒用户输入两个值
(2)接收用户数入的两个值
(3)使用三木运算符获取用户输入的值

我相信各位经历过了上面的练习,到这里应该也有思路了吧。还是那句话可以试着自己写一下。如果写不出来再去看下面的代码分析逻辑。锻炼各位的自己梳理逻辑的能力。大佬忽略哈哈~~


public static void main(String[] args) {
	//1.提醒用户输入两个值
	System.out.println("获取最大值,需要您提供两个值");
		
	//2.接受键盘输入的两个值
	Scanner scanner = new Scanner(System.in);
	int one = scanner.nextInt();
	int two = scanner.nextInt();
		
	//2.使用三目运算符获取a,b中的最大值
	//a如果大于b,为真,最大值为a,a如果不大于b,为假,最大值为b
	int max = one > two ? one : two;
	System.out.println("最大值为:"+max);
}

此次笔者就写到这里,有什么疑问或者有什么建议可以评论区告诉我,谢谢大家的支持!!!
这篇关于JAVA程序入门--基础知识(运算符)的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!