一、运算符
1、算数运算符
| 运算符 | 名称 | 举例 |
| + | 加法 | A等于10，B等于3 则A+B=13 |
| - | 减法 | A等于10，B等于3 则A-B=7 |
| * | 乘法 | A等于10，B等于3 则A*B=30 |
| / | 除法 | A等于10，B等于3 则A/B=3 |
| % | 取余 | A等于10，B等于3 则A%B=1 |
| ++ | 自增 | B++或++B等于4 |
| -- | 自减 | B--或--B等于2 |
++：意为将变量值+1，如果++出现在变量名的前面，则变量本身先加1，然后在输出；如果++出现在变量名的后面，则先输出变量本身的值，然后加1
1 public static void main(String[] args) {
2 int i=1;
3 System.out.println("i++的值-----"+(i++));
4 System.out.println("i的值-----"+i);
5 int k=1;
6 System.out.println("++k的值"+(++k));
7 }
输出的结果为
i++的值-----1
i的值-----2
++k的值2
--：意为将变量值-1，如果--出现在变量名的前面，则变量本身先减1，然后在输出，如果--出现在变量名的后面，则先输出变量本身的值，然后在减1
1 public static void main(String[] args) {
2 int i=1;
3 System.out.println("i--的值-----"+(i--));
4 System.out.println("i的值-----"+i);
5 int k=1;
6 System.out.println("--k的值"+(--k));
7
8 }
输出的结果为：
i--的值-----1
i的值-----0
--k的值0
2、赋值运算符
两个操作数进行操作，把结果再赋值给其中的一个变量
| 运算符 | 名称 | 举例 |
| = | 赋值 | 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 |
| %= | 模等于 | c%=a等价于c=c&a |
1 public static void main(String[] args) {
2 int one=10;
3 int two=3;
4 int three=0;
5 three=one+two;
6 System.out.println("three=one+two----"+three);
7 three+=one;
8 System.out.println("three+=one----"+three);
9 three-=one;
10 System.out.println("three-=one---"+three);
11 three*=one;
12 System.out.println("three*=one---"+three);
13 three/=one;
14 System.out.println("three/=one---"+three);
15 three%=one;
16 System.out.println("three%=one---"+three);
17
18 }
输出结果为
three=one+two----13
three+=one----23
three-=one---13
three*=one---130
three/=one---13
three%=one---3
3、关系运算符
关系运算符运算得到的结果类型为boolean类型
| 运算符 | 描述 | 例子 |
|---|---|---|
| == | 检查如果两个操作数的值是否相等，如果相等则条件为真。 | （A == B）为假(非真)。 |
| != | 检查如果两个操作数的值是否相等，如果值不相等则条件为真。 | (A != B) 为真。 |
| > | 检查左操作数的值是否大于右操作数的值，如果是那么条件为真。 | （A> B）非真。 |
| < | 检查左操作数的值是否小于右操作数的值，如果是那么条件为真。 | （A <B）为真。 |
| >= | 检查左操作数的值是否大于或等于右操作数的值，如果是那么条件为真。 | （A> = B）为假。 |
| <= | 检查左操作数的值是否小于或等于右操作数的值，如果是那么条件为真。 | （A <= B）为真。 |
1 public static void main(String[] args) {
2 int a = 10;
3 int b = 20;
4 System.out.println("a == b = " + (a == b) );
5 System.out.println("a != b = " + (a != b) );
6 System.out.println("a > b = " + (a > b) );
7 System.out.println("a < b = " + (a < b) );
8 System.out.println("b >= a = " + (b >= a) );
9 System.out.println("b <= a = " + (b <= a) );
10
11 }
输出结果为
a == b = false
a != b = true
a > b = false
a < b = true
b >= a = true
b <= a = false
4、逻辑运算符：
下表列出了逻辑运算符的基本运算，假设布尔变量A为真，B为假，C为真，D为假
| 运算符 | 名称 | 举例 |
| & | 与（两个变量同为真结果为真，否则为假） | A&B为假 A&C为真 B&D为假 |
| | | 或（两个变量有一个为真结果就是真，否则为假） | A|B为真 A|C为真 B|D为假 |
| ^ | 异或(两个变量相同为假，不同为真） | A^B为真 A^C为假 B^D为假 |
| ! | 非（条件为真，非后结果为假） | ！（A&B）为假 ！（A&C）为真 ！（B&D）为假 |
&& 短路与：规则与&相同，但是如果使用&&时，第一个条件为false，则不再对第二个条件进行判断，直接输出结果为false。
|| 短路或：规则与|相同，但是如果使用||时，第一个条件为true，则不再对第二个条件进行判断，直接输出结果为为true。
5、字符串连接符
String表示字符串类型，如果要申明一个字符串的变量，则变量值需要使用双引号，任何数据类型通过+和字符串类型连接，组成的依然是一个字符串
6、条件运算符
也叫三目运算符，三元运算符等，
语法：条件表达式？结果1：结果2；
注意：1、条件表达式的结果只能是boolean类型
2、如果返回的结果为true，则输出结果1，否则输出结果2
1 public static void main(String[] args) {
2 int a,b,c;
3 a=20;
4 b=(a==10)?20:30;
5 c=(a==20)?20:30;
6 System.err.println("b的值"+b);
7 System.err.println("c的值"+c);
8
9 }
输出结果为
b的值30
c的值20
7、instanceof运算符
该运算符用于操作对象实例，检查该对象是否是一个特定类型（接口类型或类类型）
语法：（object reference variable） instanceof （class/interface type）
如果运算符左侧变量所指的对象，是操作符右侧类或接口（class/interface）的一个对象，那么结果为真
例子
String name="xiaoming";
//由于name是string类型，所以返回true
boolean result =name instanceof String
如果被比较的对象兼容于右侧类型，改运算符仍然返回true
例子：
class Vehicle{}
public class car extends Vehicle{
publicstatic void main(String []args){
Vehicle a=new car();
boolean result = a instanceof Car;
Systen.out.println(result)
}
}
运行结果为
true
8、java运算符优先级
当多个运算符出现在一个表达式中，谁先谁后呢？这就涉及到运算符的优先级别的问题。在一个多运算符的表达式中，运算符优先级的不同会导致最后得出的结果差别很大
下表中具有最高优先级别的运算符在表的最上面，最低优先级的在表的最下面
| 类别 | 操作符 | 关联性 |
|---|---|---|
| 后缀 | () [] . (点操作符) | 左到右 |
| 一元 | + + - ！〜 | 从右到左 |
| 乘性 | * /％ | 左到右 |
| 加性 | + - | 左到右 |
| 移位 | >> >>> << | 左到右 |
| 关系 | >> = << = | 左到右 |
| 相等 | == != | 左到右 |
| 按位与 | ＆ | 左到右 |
| 按位异或 | ^ | 左到右 |
| 按位或 | | | 左到右 |
| 逻辑与 | && | 左到右 |
| 逻辑或 | | | | 左到右 |
| 条件 | ？： | 从右到左 |
| 赋值 | = + = - = * = / =％= >> = << =＆= ^ = | = | 从右到左 |
| 逗号 | ， | 左到右 |
二、java语句
1、条件语句
1）、if语句
语法：
if（条件语句）{
//条件成立，需要运行的代码
}else{
//可选项，当条件不成立，就执行else中的代码
}
如果有多个条件时可以选择else if和if语句匹配使用，语法：
if（条件语句）{
//调价成立，需要运行的代码
}else if(){
//条件成立，需要运行的代码
}
.....
else if(){
//条件成立，需要运行的代码
}else{
//可选项，当以上条件都不成立时，就执行else中的代码
}
【一个if语句中可以有多个else if，但只能有一个esle，而且else要位于所有else if 的后面】
2）、switch语句
语法：
switch（表达式）{
case 取值1：代码块
break；
case 取值1：代码块
break；
case 取值1：代码块
break；
case 取值1：代码块
break；
.....
default 代码块
注意：1、switch中的表达式的类型只能是byte，short，int，char，String和枚举
2、每个case语句块后面，都要跟上break，用来条出语句
3、default表示当所有条件不成立时们就会被执行。
if和switch的区别：if和switch都是条件语句，但是switch只能做等值判断，而if条件语句既可以做等值判断，也可以做范围判断
2、循环语句
顺序结构的程序语句只能被执行一次，如果想要同样的操作执行多次，就需要使用循环结构。java中有三种主要的循环结构，while循环，do....while循环，for循环
1）、while循环
while循环是最基本的循环，结构为：
while (布尔表达式）{
循环内容
}
只要布尔表达式为true，循环就会一直执行下去
1 public static void main(String[] args) {
2 int i=20;
3 while(i<30){
4 System.out.println("i的值="+i);
5 i++;
6 }
7 }
输出结果为：
i的值=20
i的值=21
i的值=22
i的值=23
i的值=24
i的值=25
i的值=26
i的值=27
i的值=28
i的值=29
2）、do...while循环
对于whlie语句而言，如果不满足条件，则不能进入循环，但有时我们需要即使不满足条件，也至少执行一次。do...whlie循环和while循环相似，不同的是，do...while循环至少会执行一次。
do{
//代码语句
}while(布尔表达式）；
例子：
1 public static void main(String[] args) {
2 int i=20;
3 do {
4 System.err.println("i的值为==="+i);
5 } while (i>20);
6
7 do {
8 System.err.println("i的值为----"+i);
9 i++;
10 } while (i<25);
11 }
输出结果为：
i的值为===20
i的值为----20
i的值为----21
i的值为----22
i的值为----23
i的值为----24
注意：布尔表达式在循环体的后面，所以语句块在检测布尔表达式之前已经执行了。如果布尔表达式的值为true，语句块一直执行，知道布尔表达式的值为false。
3）、for循环
虽然所有循环结构都可以用while或do...while表示，但是java提供了另一种语句——for循环，是一些循环结构更加简单。
for循环执行的次数是在执行前就确定的，结构为：
for(初始化；布尔表达式；更新){
//代码语句
}
for循环需要注意几点：
1、最先执行初始化步骤。可以声明一种类型，但可初始化一个或多个循环控制变量，也可以是空语句。
2、然后，检测布尔表达式的值，如果为true，循环体被执行，如果为false，循环终止，开始执行循环体后面的语句。
3、执行一次循环后，更新循环控制变量。
4、再次检测布尔表达式，循环执行上面的过程。
1 public static void main(String[] args) {
2 for(int i=0;i<5;i++){
3 System.err.println("i的值"+i);
4 }
5 }
输出结过为
i的值0
i的值1
i的值2
i的值3
i的值4
java增强的for循环
在java5以后引入了一种用于数组或集合的增强型for循环，结构为：
for(声明语句：表达式）{
//打码语句
}
声明语句：声明新的局部变量，该变量的类型必须和数组或集合元素的类型匹配。其作用域限定在循环语句块，其值与此时数组或集合元素的值相等。
表达式：表达式是要访问的数组或集合名，或者是返回值为数组或集合的方法
例子：
1 public static void main(String[] args) {
2
3 String [] strings={"小明","小李","小红","小白"};
4 for(String s:strings){
5 System.err.println("数组循环==="+s);
6 }
7 List<String> lStrings=new ArrayList<>();
8 lStrings.add("小明");
9 lStrings.add("小李");
10 lStrings.add("小红");
11 lStrings.add("小白");
12 for(String list:lStrings){
13 System.err.println("集合循环==="+list);
14 }
15 }
输出结果为：
数组循环===小明
数组循环===小李
数组循环===小红
数组循环===小白
集合循环===小明
集合循环===小李
集合循环===小红
集合循环===小白