目录 🐋🐋 先来了解一下什么是运算符吧！😆💟作者简介：大家好呀！我是路遥叶子，大家可以叫我叶子哦！❣️
📝个人主页：【路遥叶子的博客】
🏆博主信息：四季轮换叶，一路招摇胜！
专栏【小邹带你学Java】
【数据结构-Java语言描述】
🐋希望大家多多支持😘一起进步呀！~❤️
🌈若有帮助，还请【关注➕点赞➕收藏】，不行的话我再努力努力呀！💪
————————————————
⚡版权声明：本文由【路遥叶子】原创、在CSDN首发、需要转载请联系博主。
🍁想寻找共同成长的小伙伴，请点击【Java全栈开发社区】
🌲🌲🌲概念
🌲🌲🌲 Java中运算符的几大类
🐋🐋小白白—算术运算符😋🌳🌳🌳 你知道算术运算符有那些吗？
🎃🎃 注意事项，要注意避雷哦！
🌳🌳🌳 算术运算符-自增、自减
🌳🌳🌳 a++ 和++a的区别【重点】！
🎃🎃 注意事项
🐋🐋大师傅—赋值运算符😁🌲🌲🌲 关系运算符
🎃🎃 注意事项
🐋🐋高教授—逻辑运算符😍🌲🌲🌲 注意事项
🌳🌳 三元运算符
🎃🎃小试牛刀，检验一下自己吧！
🎃🎃 注意事项
🌳🌳运算符的优先级
嘿！朋友，💚运算符的运用你学会了吗💙讲解中有例题，赶紧试试检验检验自己吧！
如果文章对您有帮助，就拿起小手赶紧给博主点赞💚评论❤️收藏💙 一下吧~~~赶紧动起来，让我们一起加油学习吧！
🐋🐋 先来了解一下什么是运算符吧！😆 🌲🌲🌲概念
🌲🌲🌲 Java中运算符的几大类运算符：用来进行数据 计算/运算 的指令。
我们在学习变量时，使用了= + - * / 和( )，这都属于运算符，是Java用来进行运算的指令。
- 算术运算符 （用来进行数学运算、字符串拼接）
- 赋值运算符 （用来向变量、常量保存数据）
- 关系运算符 （用来比较两个数之间的大小关系）
- 逻辑运算符 （用来进行“真” 或 “假” 的判断）
- 三元运算符
💙 💜 ❤️ 💚💙 💜 ❤️ 💚💙 💜 ❤️ 💚💙 💜 ❤️ 💚💙 💜 ❤️ 💚💙 💜 ❤️ 💚💙 💜 ❤️
🐋🐋小白白—算术运算符😋🌳🌳🌳 你知道算术运算符有那些吗？算术运算符，主要用来进行数学运算，“+”较为特殊，也可用于字符串拼接
| 运算符 | 运算规则 | 范例 | 结果 |
| + | 正号 | +3 | 3 |
| + | 加 | 2+3 | 5 |
| + | 连接字符串 | “中”+“国” | “中国” |
| - | 负号 | int a=3;-a | -3 |
| - | 减 | 3-1 | 2 |
| * | 乘 | 2*3 | 6 |
| / | 除 | 5/2 | 2 |
| % | 模运算符 整数作除法，取余数 (小数取余无意义) | 5%2 | 1 |
🎃🎃 代码举例了解一下吧！
💦💦算术运算符：
package com.czxy.demo1;
public class Demo1 {
/**
* 算术运算符
* @param args
*/
public static void main(String[] args) {
//1、 + 号
//数学加法
System.out.println(1+1); //2
int a = 1,b=2;
System.out.println(a+b); //3
//正号（几乎不用）
System.out.println(+100);//100
//拼接字符串
String aa = "中";
System.out.println(aa+"国");
//2、 - 号
//负号
System.out.println(-10);//-10
//数学减法
System.out.println(10-1);//9
//3、* / 号
// * 号 数学乘法
System.out.println(10*10);//100
// / 号 数学除法
System.out.println(10/10);//1
}
}💦💦 除法：
package com.czxy.demo1;
public class Demo2 {
/**
* 算术运算符
* / 除法
* % 模运算符
* @param args
*/
public static void main(String[] args) {
//1、 / 除法
int num1 = 5;
// 进行除法时，若两端都是整数，结果也是整数。若可能有小数位，小数位直接被截断
System.out.println(num1/2);//2
double num2 = 5.0;
// 进行除法时，若两端有小数，结果就是小数。
System.out.println(num2/2);//2.5
System.out.println(num1/2.0);//2.5
//2、 % 模运算符 整数作除法 最后取余数
//经常用于 奇数和偶数判断
//奇数%2 余1
//偶数%2 余0
int aaa = 5;
System.out.println(aaa%2);//aaa除2 取余数 1
int bbb = 6;
System.out.println(bbb%2);//bbb除2 取余数 0
}
}
💙 💜 ❤️ 💚💙 💜 ❤️ 💚💙 💜 ❤️ 💚💙 💜 ❤️ 💚💙 💜 ❤️ 💚💙 💜 ❤️ 💚💙 💜 ❤️
🌳🌳🌳 注意事项，要注意避雷哦！1、任何数据和字符串直接进行“+”运算，都是在拼接字符串
2、除法原则：
运算两端，两端有小数，结果必为小数；
运算两端，两端均为整数，结果必为整数；有小数位，小数直接截掉。
3、0不能作为除数。
4、0不能作取余 *** 作。
NaN (Not A Number) 不是一个数字
5、算术运算符可以对变量/常量进行运算。
🎃🎃你学会了吗？下面我们要升级了哦！😎 做好准备开始啦！
💙 💜 ❤️ 💚💙 💜 ❤️ 💚💙 💜 ❤️ 💚💙 💜 ❤️ 💚💙 💜 ❤️ 💚💙 💜 ❤️ 💚💙 💜 ❤️
🌳🌳🌳 算术运算符-自增、自减| 运算符 | 运算规则 | 范例 | 结果 |
| ++ | 自增 | int a=1; a++或++a | 2 |
| -- | 自减 | int b=3; a--或--a | 2 |
自增、自减算术运算符，用来进行原数字 +1 或 -1 的 *** 作。仅 *** 作数字类型变量
package com.czxy.demo1;
public class Demo3 {
/**
* 算术运算符
* 仅针对数字类型变量有效
* ++ 自增 在原有值上+1
* -- 自减 在原有值上-1
* @param args
*/
public static void main(String[] args) {
//1、++ 自增
int aa = 10;
aa++;//让aa在原有值上+1
System.out.println(aa);
//2、-- 自减
int bb = 10;
bb--;//让bb在原有值上-1
System.out.println(bb);
double cc = 10.5;
cc++;//让cc在原有值上+1
System.out.println(cc);
}
}
💙 💜 ❤️ 💚💙 💜 ❤️ 💚💙 💜 ❤️ 💚💙 💜 ❤️ 💚💙 💜 ❤️ 💚💙 💜 ❤️ 💚💙 💜 ❤️
🎃🎃 a++ 和++a的区别【重点】！1、单行使用时，前置或后置效果相同
2、混行使用时，要细致区分前置和后置
| 名称 | 格式 | 说明 |
| ++x | 前置自增 | 先自增，后取值使用 |
| x++ | 后置自增 | 先取值使用，后自增 |
| --x | 前置自减 | 先自减，后取值使用 |
| x-- | 后置自减 | 先取值使用，后自减 |
🍁🍁代码举例试试看！
package com.czxy.demo1;
public class Demo4 {
/**
* 算术运算符
* 自增、自减 *** 作
*
* 后置：x++ 先使用变量x的值，使用完毕后，再进行+1
* x-- 先使用变量x的值，使用完毕后，再进行-1
*
* 前置：++x 先进行+1， *** 作完毕后，再进行使用变量x的值
* --x 先进行-1， *** 作完毕后，再进行使用变量x的值
* @param args
*/
public static void main(String[] args) {
//1、后置
int a = 10;
System.out.println(a++);
System.out.println(a);
//2、前置
int b = 10;
System.out.println(++b);
System.out.println(b);
}
}1、++或--只能 *** 作变量。
2、++或--仅能 *** 作数字类型变量。
❄️❄️这里要着重注意一下算术运算符的自增、自减哦！
💙 💜 ❤️ 💚💙 💜 ❤️ 💚💙 💜 ❤️ 💚💙 💜 ❤️ 💚💙 💜 ❤️ 💚💙 💜 ❤️ 💚💙 💜 ❤️
🐋🐋大师傅—赋值运算符😁| 运算符 | 运算规则 | 范例 | 结果 |
| = | 赋值 | int a=2 | 2 |
| += | 先加，后赋值 | int a=2，a+=2 | 4 |
| -= | 先减，后赋值 | int a=2，a-=2 | 0 |
| *= | 先乘，后赋值 | int a=2，a*=2 | 4 |
| /= | 先整除，后赋值 | int a=2，a/=2 | 1 |
| %= | 先取模，后赋值 | int a=2，a%=2 | 0 |
🔻 用来向变量、常量保存数据的运算符。
🔻 仅有 = 可以同时 *** 作常量和变量。
🔻 其余赋值运算符，建议仅 *** 作变量。
package com.czxy.demo2;
public class Demo1 {
/*
赋值运算符
*/
public static void main(String[] args) {
//1、= 赋值：将原有值进行覆盖 *** 作
int a = 10;
a = 20;
a = 30;
System.out.println(a);//30
//2、 += 先加后赋值
int b = 10;
b+=10;// 相当于 b = b+10;
System.out.println(b);//20
//3、 -= *= /= %=
int c = 10;
c-=10;//0
int d = 10;
d*=10;//100
int e = 10;
e/=10;//1
int f = 9;
f%=2;//1
}
}
| 运算符 | 运算规则 | 范例 | 结果 | |
| == | 相等于 | 4==3 | false | |
| != | 不等于 | 4!=3 | true | |
| < | 小于 | 4<3 | false | |
| > | 大于 | 4>3 | true | |
| <= | 小于等于 | 4<=3 | false | |
| >= | 大于等于 | 4>=3 | true | |
🔻用来比较两个数之间的大小关系，运算结果一定为布尔值。
🔻运算原则：
- 运算式条件成立，结果为true
- 运算式条件不成立，结果为false
package com.czxy.demo3;
public class Demo1 {
/*
* 关系运算符
* 如果式子成立的，返回结果true
* 如果式子不成立，返回结果false
* */
public static void main(String[] args) {
System.out.println(1==1);//true
System.out.println(1==10);//false
System.out.println(1!=10);//true
System.out.println(1!=1);//false
System.out.println(1<10);//true
System.out.println(100<10);//false
System.out.println(100>10);//true
System.out.println(1>10);//false
System.out.println(100<=100);//true
System.out.println(100<=1);//false
System.out.println(100>=100);//true
System.out.println(1>=100);//false
}
}
1、变量和常量都可参与关系运算。
2、变量或常量参与运算的执行步骤：
💙 💜 ❤️ 💚💙 💜 ❤️ 💚💙 💜 ❤️ 💚💙 💜 ❤️ 💚💙 💜 ❤️ 💚💙 💜 ❤️ 💚💙 💜 ❤️
🐋🐋高教授—逻辑运算符😍| 运算符 | 规则名 | 规则说明 | 范例 | 结果 |
| & | 与 | 有false为false 两侧 *** 作数必须全为true，才会返回true。 否则返回false。 | false&true | false |
| | | 或 | 有true为true 两侧 *** 作数只要有一个为true，就返回true。 全为false才返回false。 | false|true | true |
| ! | 非 | 返回相反值 | !true | false |
| ^ | 异或 | 两侧 *** 作数不相同，返回true。 两侧 *** 作数相同，返回false。 | true^false | true |
| && | 短路与 | 有false为false 两侧 *** 作数必须全为true，才会返回true。 否则返回false。 | false&&true | false |
| || | 短路或 | 有true为true 两侧 *** 作数只要有一个为true，就返回true。 全为false才返回false。 | false||true | true |
🔻 用来进行“真” 或 “假” 的运算和判断。
🔻 注：逻辑运算符只能对布尔值运算，运算结果一定是布尔值。
&& 同真则真，有假则假 || 有真则真，同假则假 ! 取相反 ^ 不同为真，相同则假
- 下面是运算符的运算规则【口诀】 && || ! ^
💦💦 代码举例试试吧!
package com.czxy.demo4;
public class Demo1 {
/**
* 逻辑运算符
* & 有false为false 如果今天风很大 并且 今天要下雨 我就不出门了
* 并且 &
*
* | 有true为true 如果今天太阳大 或者 今天没吃饭 我就不出门了
* 或者 |
* ! 取相反值
* @param args
*/
public static void main(String[] args) {
//1、 & 与
System.out.println(true&true);//true
System.out.println(false&true);//false
//2、 | 或
System.out.println(true|true);//true
System.out.println(false|true);//true
System.out.println(false|false);//false
//3、 ！ 非
System.out.println(!true);//false
System.out.println(!false);//true
}
}
package com.czxy.demo4;
public class Demo2 {
/**
* 逻辑运算符
* 短路 *** 作：能确定结果，就不再向后运算了.可以提升运算效率
*
* && 有false为false 如果今天风很大 并且 今天要下雨 我就不出门了
* 并且 &&
*
* || 有true为true 如果今天太阳大 或者 今天没吃饭 我就不出门了
* 或者 ||
* @param args
*/
public static void main(String[] args) {
//1、 &&
System.out.println(true && true);//true
System.out.println(false && true);//false
//2、 ||
System.out.println(false || false);//false
System.out.println(true || false);//true
}
}
package com.czxy.demo4;
public class Demo3 {
/**
* 逻辑运算符
* 感受短路 *** 作;能提升程序的运行效率
* @param args
*/
public static void main(String[] args) {
int a = 10;
System.out.println(true || ++a>10);
System.out.println(a);//10
int b = 10;
System.out.println(false && ++b>10);
System.out.println(b);//10
}
}
短路：即只要能判断出结果，就直接返回结果。 运算符后面的判断就不会再执行。日常开发中全部使用短路 *** 作。 逻辑运算符两端 *** 作数可以是两个布尔值常量，也可以是两个布尔表达式。 （布尔表达式/条件表达式：即最终会返回布尔值的运算式）
💙 💜 ❤️ 💚💙 💜 ❤️ 💚💙 💜 ❤️ 💚💙 💜 ❤️ 💚💙 💜 ❤️ 💚💙 💜 ❤️ 💚💙 💜 ❤️
🌳🌳 三元运算符🔻 三元运算符即三个 *** 作数参与计算的运算符。
格式： (布尔表达式)？结果1:结果2; 结果1或结果2可以是任何数据类型（基本数据类型，引用数据类型） 运算规则： 根据布尔表达式的值返回不同的结果： 布尔表达式为true， 返回 结果1 布尔表达式为false， 返回 结果2
int i = 10;
int j = 20;
System.out.println(i>j?"i的值大":"j的值大");
//打印结果为j的值大package com.czxy.demo1;
public class Demo1 {
/**
* 三元运算符
* (布尔表达式)?结果1:结果2;
*
* 1、结果1和结果2永远不会同时执行的
* 2、布尔表达式为true，运行结果1
* 布尔表达式为false，运行结果2
* 3、结果1和结果2 的值为任意类型
* @param args
*/
public static void main(String[] args) {
System.out.println(1==1?"等于":"不等于");//等于
System.out.println(1!=1?10.55:11.55);//11.55
}
}
注：三元运算符的结果必须被使用，否则Java报错。
package com.czxy.demo1;
public class Demo2 {
/**
* 三元运算符
* 三元运算符的结果必须被使用，否则会报错
* @param args
*/
public static void main(String[] args) {
//1、结果被使用，无报错
System.out.println(1==1?"等于":"不等于");
boolean f1 = 1==1?true:false;//允许
//2、结果未被使用，就会报错
// 1==1?true:false;
}
}1、写一个程序判断1到10的数是奇数还是偶数,打印出如下效果：
1 是奇数
2 是偶数
……
9 是奇数
10 是偶数
注：可以通过 模%运算取余来判断是奇数还是偶数。
💦 方法一：直接取余判断输出结果 。
/**
* 1、写一个程序判断1到10的数是奇数还是偶数,打印出如下效果：
* 1 是奇数
* 2 是偶数
* ……
* 9 是奇数
* 10 是偶数
* @param args
*/
public static void main(String[] args) {
//1、定义一个变量，保存1~10的数
int num = 1;
//2、依次进行判断奇偶数，并展示结果
System.out.println(num+"\t是"+((num++%2==0)?"偶数":"奇数"));
System.out.println(num+"\t是"+((num++%2==0)?"偶数":"奇数"));
System.out.println(num+"\t是"+((num++%2==0)?"偶数":"奇数"));
System.out.println(num+"\t是"+((num++%2==0)?"偶数":"奇数"));
System.out.println(num+"\t是"+((num++%2==0)?"偶数":"奇数"));
System.out.println(num+"\t是"+((num++%2==0)?"偶数":"奇数"));
System.out.println(num+"\t是"+((num++%2==0)?"偶数":"奇数"));
System.out.println(num+"\t是"+((num++%2==0)?"偶数":"奇数"));
System.out.println(num+"\t是"+((num++%2==0)?"偶数":"奇数"));
System.out.println(num+"\t是"+((num++%2==0)?"偶数":"奇数"));
}💦 方法二：循环取余判断输出。
package com.czxy.demo1;
public class Demo3_2 {
/**
* 1、写一个程序判断1到1000的数是奇数还是偶数,打印出如下效果：
*
* 引入for
* 用来进行重复代码书写。 循环
* @param args
*/
public static void main(String[] args) {
//1、定义一个变量，保存1~10的数
int num = 1;
//2、依次进行判断奇偶数，并展示结果
for (int i = 1; i <=1000 ; i++) {
System.out.println(num+"\t是"+((num++%2==0)?"偶数":"奇数"));
}
}
}2、写程序比较两个整数 22和99的大小，并且将最大值和最小值分别保存不同的变量中。
展示效果：
public static void main(String[] args) {
//1、定义变量，max,min
int max,min;
//2、为max和min赋值
max = 99>22?99:22;//如果99比22大，保存99为最大值。
min = 99>22?22:99;//如果99比22大，保存22为最小值。
//3、展示控制台
System.out.println("最大值为："+max);
System.out.println("最小值为："+min);
}1、 常量和变量都可以参与运算。
2、运算符一般只 *** 作基本数据类型，不 *** 作引用数据类型（String除外）
🌳🌳运算符的优先级在日常开发中，一行代码中很可能 出现多个不同的运算符。
比如，当赋值运算符 = 与 + 运算符都作用在一个变量上时，先计算加法，再计算赋值。
如：
int i,j;
i = 10;
//对i这个变量有两个运算符 *** 作，分别为=与+。
j = i + 20;
System.out.println(j);
//最终打印结果为30。说明先计算+后计算=。优先级：每个运算符都有一个顺序等级，来决定哪个运算符更为优先执行。
💚 运算符运算的先后顺序，数字越小，优先级越高，计算顺序越靠前。例如：先做加减，后做赋值----int a=5+1; ❤️优先级相同的情况下，按照从左到右的顺序依次运算。例如：int a=5+1-1; 因为加和减优先级相同，就从左到右顺序执行。
❄️❄️ 优先级规则表：
| 优先级 | 描述 | 运算符 |
| 1 | 括号 | ()、[] |
| 2 | 正负号 | +、- |
| 3 | 自增自减，非 | ++、--、! |
| 4 | 乘除，取余 | *、/、% |
| 5 | 加减 | +、- |
| 6 | 移位运算 | <<、>>、>>> |
| 7 | 大小关系 | >、>=、<、<= |
| 8 | 相等关系 | ==、!= |
| 9 | 按位与 | & |
| 10 | 按位异或 | ^ |
| 11 | 按位或 | | |
| 12 | 逻辑与 | && |
| 13 | 逻辑或 | || |
| 14 | 条件运算 | ?: |
| 15 | 赋值运算 | =、+=、-=、*=、/=、%= |
| 16 | 位赋值运算 | &=、|=、<<=、>>=、>>>= |
注（这里是个小技巧哦！）：如果分不清优先级想让谁先运行，就加 括号( )
因为优先级规则表并不方便开发中的程序员随时使用， 所以开发中我们通常使用小括号 ( ) 来改变运算符优先级，使得程序按照程序员的预想来执行。嘿！朋友，运算符的运用你学会了吗？讲解中有例题，赶紧试试检验检验自己吧！ 如果文章对您有帮助，就拿起小手赶紧给博主点赞💚评论❤️收藏💙 一下吧~~~赶紧动起来，让我们一起加油学习吧！
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）