1，算术运算符

分类：

+	-	*	/	%

运算规则：

+	-	*	都跟小学里面一模一样。

除法跟以前是不一样的。

• 在Java中，整数相除，结果只能得到整数。
• 在Java中，小数相除，结果有可能是不精确的。

案例：

// 除法 运算符
// 1,在代码中除法运算符如何打出来
// 2,除法在代码中的细节

int a1 = 10;
int b1 = 2;
int result1 = a1 / b1;
System.out.println(result1);


//在Java中整数相除，结果只能得到整数。
int a2 = 10;
int b2 = 3;
int result2 = a2 / b2;
System.out.println(result2);//3

//在Java中小数相除，结果有可能是不精确的。
double a3 = 10.0;
double b3 = 3.0;
double result3 = a3 / b3;
System.out.println(result3);//3.3333333333333335

2，% 取余 取模

运算规则：

获取余数。

案例1：

// % 取余 取模
int a = 10;
int b = 2;
int result = a % b;
System.out.println(result);//0
//因为10除以2，是可以整除的，所以商5余0.
//%获取的是余数，所以，结果就是0

案例2：

// % 取余 取模
int a = 10;
int b = 3;
int result = a % b;
System.out.println(result);//1
//因为10除以3，是不可以整除的，所以商3余1.
//%获取的是余数，所以，结果就是1

3，字符串+的操作

运算规则：

字符串+任意的数据类型，任意的数据类型+字符串。

都是把里面的内容原样拼接在一起。

重点：(判断技巧)

如果有多个+连续。

从左到右依次+，如果在这个过程中，没有字符串，那么就是正常的相加。如果有字符串，就是拼接操作。

案例1：

System.out.println('a' + "itheima");//aitheima

案例2：

System.out.println(1 + 2 + "abc" + 2 + 1);//3abc21
第一步：1+2。在这个过程中，没有字符串，所以进行正常的相加。结果为3.
第二步：3+"abc"。在这个过程中，有字符串，所以进行拼接操作。结果为一个新的字符串 "3bac"
第三步："3abc"+2。在这个过程中，有字符串，所以进行拼接操作。结果为一个新的字符串 "3abc2"
第四步："3abc2"+1。在这个过程中，有字符串，所以进行拼接操作。结果为一个新的字符串 "3abc21"

案例3：

System.out.println('a' + "bcd" + 1);//abcd1
第一步：'a' + "bcd"。在这个过程中，有字符串。所以进行拼接操作。结果为一个新的字符串"abcd"
第二步："abcd" + 1 。在这个过程中，有字符串。所以进行拼接操作。结果为一个新的字符串"abcd1"

案例4:

System.out.println(1 + 'a' + "bcd" + 2 + 1);//98bcd21
第一步：1 + 'a'。在这个过程中，没有字符串。所以进行正常的加法运算。结果为98.
第二步：98 + "bcd"。在这个过程中，有字符串。所以进行拼接操作。结果为一个新的字符串"98bcd"
第三步："98bcd" + 2。在这个过程中，有字符串。所以进行拼接操作。结果为一个新的字符串"98bcd2"
第四步："98bcd2" + 1。在这个过程中，有字符串。所以进行拼接操作。结果为一个新的字符串"98bcd21"

字符串拼接的练习：

//定义一个变量记录姓名
String name = "靓仔";
//定义一个变量记录年龄
int age = 2;
//定义一个变量记录身高
double height = 1.5;
//定义一个变量记录性别
char gender = '男';
//定义一个变量记录爱好
String hobby = "唱跳RapJava";

System.out.println("姓名为：" + name);
System.out.println("年龄为：" + age);
System.out.println("身高为：" + height);
System.out.println("性别为：" + gender);
System.out.println("爱好为：" + hobby);

案例：获取一个数字上个位，十位，百位

//定义一个变量
int number = 123;
//获取这个数字的个位
int ge = number % 10; //余 3
//获取十位
int shi = number / 10 % 10;// 123 / 10 = 12
//12 % 10 = 商1余2  结果为2
//获取百位
int bai = number / 100 % 10; //123/ 100 = 1
System.out.println(ge);
System.out.println(shi);
System.out.println(bai);

公式：

如果要获取一个数的个位： 数 % 10

如果要获取一个数的十位： 数 / 10 % 10

如果要获取一个数的百位： 数 / 100 % 10

如果要获取一个数的千位： 数 / 1000 % 10

如果要获取一个数的万位： 数 / 10000 % 10

…

4，赋值运算符

= +=

运算规则：

=：就是把右边赋值给左边。

int a = 1;

+=：把左边和右边进行相加，再把最终的结果赋值给左边。

int a = 1;
int b = 2;
a += b;//即a = a + b;
System.out.println(a);//3
System.out.println(b);//2

//先把左边a和右边b进行相加，把结果3赋值给左边的变量a
//对右边的变量b是没有任何影响的。
//a += b 相当于 a = a + b; 

+=细节：

底层包含了一个强制类型的转换

byte a = 1;
byte b = 2;
a+=b;
System.out.println(a);//3
System.out.println(b);//2

//a+=b 相当于a = a + b;
//因为变量a和变量b是byte类型，所以在参与运算的时候，类型会自动提升为int。
//a = a + b等号的右边，其实就是两个int相加。
//把一个int赋值给左边的byte，大的给小的，就报错了。
//而代码真正运行的时候没有报错，所以，我们推断+=底层隐藏了一个强制类型转换。

所以，+= 真正的其实是下面的过程：

byte a = 1;
byte b = 2;
a += b;
//a+=b，相当于 a = (byte)(a + b);
//+=底层隐含了一个强制类型的转换

5，自增自减运算符

重点掌握：自增自减运算符单独写一行时的运算逻辑。

运算规则：

自增自减运算符是针对于变量而言的。

不能拿着常量去自增，自减。  

++ 把变量里面的值+1

-- 把变量里面的值-1	

案例一：

int age = 16;
age++;//把变量里面的值+1，此时变量里面记录的值为：17
System.out.println(age);//17

++age;//把变量里面的值+1，此时变量里面记录的值为：18
System.out.println(age);//18

案例二：

int number = 10;
number--;//把变量里面的值-1.此时变量里面记录的值为：9
System.out.println(number);//9
--number;//把变量里面的值-1.此时变量里面记录的值为：8
System.out.println(number);//8

称呼：

a++；后++

++a；先++

注意点：不管是先++，还是后++，单独写成一行的时候，运算规则是一模一样的。这个也是要大家重点掌握的。

了解：

后++   先用后加

规则：先把原来的值拿出来参与运算，然后再进行自增

案例：

int a = 10;
int b = a++;
System.out.println(a);//11

//先把原来的值10拿出来，赋值给b。
//然后再自增。
System.out.println(b);//10

先++  先加后用

规则：先进行自增，然后再把自增之后的结果参与运算

案例：

int a = 10;
int b = ++a;
System.out.println(a);//11
//先进行自增，变量a里面的值已经为11了。然后再把自增之后的结果11赋值给b。
System.out.println(b);//11

案例：

int x = 10;
//先把原来的值拿出来参与运算，然后再进行自增
//先把原来的值10拿出来赋值给y，然后再进行自增，所以第二行代码执行完毕之后：x=11 y=10
int y = x++;

//在开始执行第三行代码的时候，x的值是为11
//先进行自增，然后再把自增之后的结果参与运算
//先把x的值进行自增，变成12，然后再把自增后的结果赋值给z。所以第三行代码执行完毕之后：x=12 z=12
int z = ++x;

//因为上面自增了两次，所以x的值就是12.
System.out.println(x);//12
System.out.println(y);//10
System.out.println(z);//12

6，关系运算符

又叫：比较运算符

注意点：

• 大于等于和小于等于的书写
  • 大于等于 >=
  • 小于等于 <=
• 千万不要把==写成=
  • ==是判断
  • =是赋值

案例：

int a = 10;
int b = 20;
//==
System.out.println(a == b);//false
//!=
System.out.println(a != b);//true
//>
System.out.println(a > b);//false
//>=
System.out.println(a >= b);//false
//<
System.out.println(a < b);//true
//<=
System.out.println(a <= b);//true

7.逻辑运算符

& | ! ^

//逻辑与（且） --- 只要两都是真，结果才是真。
// 只要有一个为假，那么结果就是假。
System.out.println(true & true);//true
System.out.println(true & false);//false
System.out.println(false & true);//false
System.out.println(false & false);//false


//逻辑或  --- 只要两都是假，结果才是假。
//只要有一个为真，那么结果就是真。
System.out.println(true | true);//true
System.out.println(true | false);//true
System.out.println(false | true);//true
System.out.println(false | false);//false

//逻辑非 --- 取反
System.out.println(!false);//true
System.out.println(!true);//false
建议：取反最多只能写一个。
不能这么写：!false
    
    
//^  了解一下就可以了
//逻辑异或（^）  相等就是false
//两边不等就是true
System.out.println(true ^ true);//false
System.out.println(true ^ false);//true
System.out.println(false ^ true);//true
System.out.println(false ^ false);//false 

应用场景：

在登录的时候，用户会把用户名和密码都传递给服务器。

用户名正确 & 密码正确 //正确的
用户名正确 | 密码正确

第一个老丈母娘要求：要么有房，要么有车。才能把我的小棉袄穿走啊。
有房 & 有车
有房 | 有车//正确的

第二个老丈母娘要求：既要有房，又要有车。才能把我的小棉袄穿走啊。
有房 & 有车//正确的
有房 | 有车

核心：

&：需要两边同时满足条件时。

|：两边只要有一个满足条件时。（两者选其一）

8，短路逻辑运算符

分类：

&& ||

&& 案例：

在登录的时候，用户会把用户名和密码都传递给服务器。

用户名正确 && 密码正确
//如果用户名已经输入错误了，那么密码就没有执行的必要了。
//如果用户名输入正确了，那么密码就有比较的必要。


用户名正确 & 密码正确
//不管你用户名输入的正确的还是错误的，那么右边的密码都会进行比较。

结论1：短路&&，一旦左边能确定最终的结果，那么右边就不会执行了。

false（用户名错误） && … //右边此时就不需要比较了。从而提高了程序的运行效率。

结论2：&&的执行效率要更高。

|| 案例：

老丈母娘要求：要么有房，要么有车。才能把我的小棉袄穿走啊。
有房 || 有车
//情况一：首先先看||的左边，此时发现，你已经有房了。那么就不需要再看右边有没有车了。此时牵手成功。
//情况二：首先先看||的左边，此时发现，暂时还没有方法。那么就需要看右边有没有车了。


有房 | 有车
//不管你有没有房，那么左右两边都会去看。

结论1：短路||，一旦左边能确定最终的结果，那么右边就可以不需要执行了。

结论2：||的执行效率要更高。

9，逻辑运算符的小结：

用的比较多的建议：

&& 			||	 		!

10，三元表达式

格式：

关系表达式 ？表达式1 : 表达式2 ；

在这个格式当中，问号和冒号是固定格式。分号表示语句结束。

执行过程：

首先计算关系表达式的值。这个值必须是一个布尔类型的结果。

如果为true，那么表达式1的结果，就是整个三元表达式的结果。

如果为false，那么表达式2的结果，就是整个三元表达式的结果。

注意点：

三元表达式的最终结果必须要被使用。

• 要么赋值给一个变量
• 要么直接输出

案例1：

//定义两个变量记录两只老虎的体重
int weight1 = 180;
int weight2 = 200;

//三元表达式来计算判断
//三元表达式的结果，必须要被使用。
//要么把结果赋值给一个变量，要么把结果直接输出。
String result = weight1 == weight2 ? "相同" : "不相同";
System.out.println(result);

//直接把三元表达式放到输出语句当中。
//此时打印的就是三元表达式最终的结果了。
System.out.println(weight1 == weight2 ? "相同" : "不相同");

案例2：

//定义三个变量去记录三个和尚的身高
int height1 = 150;
int height2 = 210;
int height3 = 165;

//先比较第一个和第二个的身高。得到较大值。
int temp = height1 > height2 ? height1 : height2;
//拿着较大值，再跟第三个比较。得到最大值。
int max = temp > height3 ? temp : height3;
//输出最大值
System.out.println(max);

11，键盘录入

目的：

就是接收用户在键盘上录入的数据。

步骤：

1，导包

	告诉虚拟机Scanner这个类在哪。

2，创建对象

	打个招呼，我现在准备开始用这个类了。

3，接收数据

	真正干活的代码

//1,导包 --- 告诉虚拟机，Scanner这个类在哪？
import java.util.Scanner;

public class ScannerDemo{
	public static void main(String [] args){
		//2，创建对象 --- 打个招呼，要开始用这个类了。
		Scanner sc = new Scanner(System.in);
		//3.接收数据 --- 才是真正使用这个类的功能
		System.out.println("请录入一个数");
		int number = sc.nextInt();
		
		//输出刚刚键盘录入的变量
		System.out.println("刚刚录入的数据为:"+number);
	}
}

注意点：

sc.nextInt();只能接收整数，不能接收小数或者字符串。

如果输入了小数或者字符串，程序就会报错。

12，idea

具体使用请参见资料中的pdf文件。
链接：https://pan.baidu.com/s/1NnDz7gW78N5FtoXusoBkdQ
提取码：usy4
复制这段内容后打开百度网盘手机App，操作更方便哦–来自百度网盘超级会员V3的分享

快捷键：

psvm + 回车  快速生成main方法

sout 快速生成输出语句

其他的快捷键，我们在后面写代码的时候，会挨个带着大家去学习的。
加油各位