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--” 后置自减，会先输出结果再自减
| 操作符 | 描述 | 例子 |
|---|---|---|
| "++" | 自增···操作的值增加1 | 20++ 或 ++20 等于 21 |
| "--" | 自减···操作的值减少1 | 20-- 或 --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);
}
此次笔者就写到这里，有什么疑问或者有什么建议可以评论区告诉我，谢谢大家的支持！！！