运算符
概述：对常量与变量进行运算操作的符号称为运算符。
组成：
三元运算符：
格式：（比较表达式）？表达式1:表达式2；
注意：三元表达式的结果必须是一个值。可以比较后赋值，也可以直接输出结果。
嵌套格式：（比较表达式）？（比较表达式）?表达式1:表达式2（比较表达式）？表达式1:表达式2;
算数运算符：+（正号）-（负号）+（加）-（减）*（乘）/（除）%（取余）
++（自增）--（自减）+（字符串连接符）。
赋值运算符：=、+=、-=、*=、/=、%=。
比较运算符：==、！=、>、<、>=、<=、%=。
逻辑运算符：&、|、&&、||、^、！。
结果：true&true=true true&false=false false&false=false
结果：true|true=true true|false=true false|false=false
过程：&&、|| 当第一个判断已经能确认结果时，后面不参与运算。
结果：true^true=false true^false=true false^false=false false^true=true
结果：!true=false !false=true
位运算符：<<（左移）、>>（右移）、>>>（无符号右移）&（与）|（或）^（异或）~（反码）
概述：对二进制进行运算，是最有效率的运算方式。
8<<2：对二进制00001000左移两位空位补零，移出的丢弃，结果为00100000，十进制32。
8>>2：对二进制00001000右移两位，最高位是0补0是1补1，移出的丢弃，结果为
00000010，十进制2。
3>>>1：对二进制00000011右移两位，不管最高位是0或1都补0，结果为00000001，十进制1。
-8>>>3：因为内存中是对补码进行操作，所以要先得出-8的补码，
原码： 10000000 00000000 00000000 00001000
反码：11111111 11111111 11111111 11110111
补码：11111111 11111111 11111111 11111000
右移三位：00011111 11111111 11111111 11111111
由于右移后最高位是0，变成了正数，而正数的原反补相同，所以结果为十进制536870911
&（位与运算）两个二进制位上的数相比较，有0则0，无0则1。
|（位或运算）两个二进制位上的数相比较，有1则1，无1则0。
^（位异或运算）两个二进制位上的数相比较，相同则0，不同则1。
~（反码）对一个数进行取反操作。
语句
顺序结构
程序从上往下依次执行代码称为顺序结构。
class Demo{
public static void main(String[] args){
System.out.println(1);
System.out.println(2);
System.out.println(3);
System.out.println(4);
}
}选择结构
if语句：
格式一：if(条件表达式){执行语句体;}
/*
例子：比较一个数是否等于一个数。
*/
public static void main(String[] args){
int x = 3;
if(x==3){
System.out.println("恭喜匹配正确");
}
}格式二：if(条件表达式){执行语句体;}else{执行语句体}
/*
比较表达式结果为true执行if中的语句体，false则执行else中的语句体；
*/
public static void main(String[] args){
int x = 3;
if(x==5){
System.out.println("恭喜匹配正确");
}else{
System.out.println("数字与答案不匹配");
}
}格式三：if(条件表达式){
语句体1;}elseif(条件表达式){
语句体2;}elseif(条件表达式){
语句体3+n;}else{
语句体n}
/*
格式三适用于多层判断，可以有无数个else if，当前面都不匹配时执行else中的代码。
*/
public static void main(String[] args){
//输入成绩查询段位
int x =99;
if(x>=0&&x<=20){
System.out.println("青铜");
}else if(x>=21&&x<=40){
System.out.println("白银");
}else if(x>=41&&x<=60){
System.out.println("黄金");
}else if(x>=61&&x<=70){
System.out.println("铂金");
}else if(x>=71&&x<=80){
System.out.println("钻石");
}else if(x>=81&&x<=90){
System.out.println("星耀");
}else if(x>=91&&x<=100){
System.out.println("王者");
}else{
System.out.println("请输入正确的成绩0-100");
}
}判断结构
switch语句：
格式：switch(选择表达式){
case值:
执行语句体；
break；
default：
执行语句体；
break；
}
特点：switch语句操作的类型只有short,byte,int,char。
循环结构
格式：for(初始化表达式;循环条件;循环后操作){
循环体语句；
}
注意：break结束当前循环；continue结束本次循环执行下一次循环；
格式：while(循环条件){
循环体语句；
控制结束语句；
}
格式：do{
循环体语句；
控制结束条件；
}while（循环条件）；
方法
定义：方法就是定义在类中的具有完成某些功能的代码块。
格式：修饰符 返回值类型 方法名 （参数类型 参数1，参数类型 参数2）{
代码块；
return 返回值；
}
特点：
1、定义函数可以将功能代码进行封装。
2、便于对该功能进行复用。
3、函数只有被调用才会被执行。
4、函数的出现提高了代码的复用性。
注意：写方法前的两个需要确认的问题，1、返回值类型是什么？2、参与运算的参数个数以及
类型。
方法的重载：Java中允许多个方法使用同样的名称，只要参数列表个数或者参数类型不同即可。
这样就无需使用者自己去选择使用哪个方法，程序会根据传递的参数类型或个数自
动匹配。
数组
定义：可以存储多个同类型变量的容器。
格式一：数组类型[]数组名 = new 数组类型[元素个数或数组长度];
格式二：数组类型[]数组名 = new 数组类型[]{数组中的元素};
解释：格式1适用于元素未知但个数明确，格式2适用于个数以及值都明确。
数组的常见操作：
数组遍历：
/*
练习：数组遍历
需求：定义一个数组并遍历输出其中的元素。
分析：使用for循环完成。
*/
class Demo{
public static void main(String[] args){
//定义一个数组并存入数据。
int [] arr = new int[]{9,4,5,3,1,2,7,8,6,0};
//从0角标开始遍历，当遍历到等于数组长度-1的角标时结束循环。
for(int x=0;x<arr.length;x++){
System.out.print("["+arr[x]+"],");
}
}
}
获取最值：
/*
练习：获取数组中的最大值
需求：定义一个数组并遍历比较其中的值，输出最大值。
分析：使用for循环嵌套if完成。
*/
class Demo{
public static void main(String[] args){
//定义一个数组并存入数据。
int [] arr = new int[]{0,4,5,3,1,2,7,8,6,9};
//定义一个变量max存放最大值，tep存放零时较大值。
int max,tep=arr[0];
//从0角标开始遍历，当遍历到等于数组长度-1的角标时结束循环。
for(int x=1;x<arr.length;x++){
if(tep<arr[x]){
tep = arr[x];
}
}
max = tep;
System.out.println("最大值为："+max);
}
}
元素逆序：
class Demo{
public static void main(String[] args){
int[] arr={9,8,7,6,5,4,3,2,1};
niXu(arr);
for(int x=0;x<arr.length;x++){
System.out.print(arr[x]+" ");
}
System.out.print("\n");
}
public static int[] niXu(int[] arr){
for(int x=0;x<arr.length/2;x++){
int tep=arr[x];
arr[x]=arr[arr.length-1-x];
arr[arr.length-1-x]=tep;
}
return arr;
}
}
元素排序：
/*
需求：
元素排序：冒泡排序
*/
class Demo{ //定义一个Java类并起名为Demo
public static void main(String[] args){ //程序的main方法，作为程序执行的入口。
int [] arr={9,8,3,5,2}; //定义一个int类型的数组并在堆内存中开辟一个空间同时赋值。
System.out.print("冒泡排序前："); //输出说明字符串
daYing(arr); //调用遍历输出方法，输出数组中的值
paiXu(arr); //调用排序方法，对数组中的值进行排序
System.out.print("冒泡排序后："); //输出说明字符串
daYing(arr); //调用遍历输出方法，遍历输出排序后的数组值。
}
//定义打印数组的方法
public static void daYing(int[] arr){ //定义一个方法类型为void，参数列表为接收一个int类型的数组，起名为arr
//循环遍历数组的元素
for(int i=0;i<arr.length;i++){ //定义一个for循环，初始化语句为定义一个int类型变量i赋值为0，判断i小于数组长度则执行语句体，
System.out.print(arr[i]+" "); //第一次循环输出arr[i]的值，第一次i是0，循环完成后i++变成1.小于数组长度则再次执行输出语句，
} //第二次arr[i]，i的值变成1。以此类推，直到i不小于数组长度。以此实现数组的遍历。
System.out.print("\n"); //\n，转移字符n，换行。
}
//定义对数组排序的方法
public static void paiXu(int [] arr){ //定义一个类型是void的方法，参数列表一个，参数类型为int类型数组起名为arr
for (int i=0; i<arr.length -1; i++){ //外层循环，用于控制总体比较的次数。在第一次比较时最大值已经到了最后，所以最后一个不需要在次比较，-1操作。
for (int j=0; j<arr.length -i -1; j++){ //内层循环，用于控制每次的比较，比较排好序的值不需要再次比较，所以-i -1操作。
if(arr[j]>arr[j+1]){ //判断两个相邻的值中的较大值
int temp=arr[j]; //如果前者比后者大，则通过第三方变量的方式把他俩的值互换，然后拿换后大的值再跟相邻的值比较，以此类推，直到条件结束。
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
System.out.print("第"+(i+1)+"轮排序后"); //输出每一轮排序后的值。
daYing(arr);
}
}
}二维数组：
定义：数组是变量的容器，而二维数组就是数组的容器，可以存放多个数组。
格式：
格式1、int [][] arr =new int[3][4];
格式说明：int后面跟两个[]就说明这是一个二维数组，然后new一个3是三个数组，4是每个数组的长度为4。
格式2、int [][] arr =new int[3][];
格式说明：跟第一种格式类似，只是没指定数组的长度，后面可以单独指定每个数组的长度。
格式3、int[][] arr ={{1,2},{3,4,5,},{6,7},{8,9}};
格式说明：上面定义了四个数组，并分别静态初始化赋值。
访问操作二维数组也是通过角标的方式，例如格式2定义了3个数组但没有指定长度跟赋值。那么就可以通过arr[0] = new int[] {1,2};来赋值，而要操作这个值1，则用arr[0][0]来访问。
