基本语法
一、关键字 & 标识符
关键字：被Java语言赋予了特殊含义，用做专门用途的字符串（单词）
保留字：
标识符：凡是自己可以起名字的地方都叫标识符
命名的规则：（一定要遵守，不遵守就会报编译的错误）
由26个英文字母大小写，0-9，_或$组成
数字不可以开头。
不可以使用关键字和保留字，但能包含关键字和保留字。
Java中严格区分大小写，长度无限制。
标识符不能包含空格。
Java中的名称命名规范：（不遵守，也不会出现编译的错误）
包名：多单词组成时所有字母都小写：xxxyyyzzz
类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz
变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大小写：xxxYyyZzz
常量名：所有字母都大写。多单词里每个单词用下划线连接：XXX_YYY_ZZZ
二、变量
1.java中变量按照数据类型来分类：基本数据类型 vs 引用数据类型(数组 类 接口)
>基本数据类型：
整型：byte(8 bit) short int（默认类型） long
浮点型：float double（默认类型）
字符型：char('')
布尔类型：boolean（只能取值为true 或 flase，不能取null）
补充：按照在类中存在的位置的不同：成员变量 vs 局部变量
2.进制（了解）
十进制 二进制 八进制 十六进制
二进制：计算机底层都是用二进制来存储、运算。
>二进制与十进制之间的转换。
>二进制在底层存储：正数、负数都是以补码的形式存储的。（原码、反码、补码）
>四种进制间的转换
3.变量的运算：
①自动类型转换：容量小的数据类型自动转换为容量大的数据类型。
short s = 12;
int i = s + 2;
注意：byte short char 之间做运算，结果为int型！
②强制类型转换：是①的逆过程。使用"()"实现强转。
三、运算符
运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。
算术运算符：
+ - + - * / % ++ -- +
注意：1）/：int i = 12; j = i / 5;
2）%：最后的符号只跟被模数相同
3）前++：先+1，后运算 后++：先运算，后+1
4）+：当String字符串与其他数据类型只能做连接运算。System.out.println('*'+'\t'+'*');vs System.out.println("*"+'\t'+'*');
赋值运算符
= += -= *= /= %=
int i = 12;
i = i * 5;
i *= 5//与上一行代码同样的意思
【特别地】
short s = 10;
s = s + 5;//报编译的异常
s = (short)(s + 5);
s += 5;//s = s + 5，但是结果不会改变s的数据类型。
比较运算符（关系运算符）
== > < >= <= instanceof
【注意】区分== 与 = 区别。
进行比较运算操作以后，返回一个boolean类型的值
4>=3 表达的是4 > 3或者4 = 3结果是true.
if(i >1 &&
i < 10){ }
不能写为：if(1 < i < 10){ }
逻辑运算符（运算符的两端）
& && | || ^ !
【注意】区分 & 与 && 的区别，以及 | 与 || 的区别
我们使用的时候，选择&&，||
位运算符（两端是数值类型的数据）
<< >> >>> & | ^ ~
【例子】1.如何交换m = 12 和n = 5的值
2.将60转换为十六进制输出。
三元运算符
(条件表达式) ? 表达式1 : 表达式2;
1）既然是运算符，一定会返回一个结果，并且结果的数据类型与表达式1，2的类型一致
2）表达式1与表达式2的数据类型一致。
3）使用三元运算符的，一定可以转换为if-else，反之不一定成立。
例子：获取两个数的较大值；获取三个数的最大值。
四、流程控制
1.顺序结构
>程序从上往下的顺序执行
2.分支结构
if-else
switch-case
1.条件判断：
①if(条件表达式){ }
②if(条件表达式){
//执行的语句1;
}else{
//执行的语句2;
}
③if(条件表达式1){
//执行的语句1;
}else if(条件表达式2){
//执行的语句2;
}else if(条件表达式3){
//执行的语句3;
}……
}else{
//执行的语句;
}
【注意】
1.一旦满足某个条件表达式，则进入其执行语句块执行，执行完毕，跳出当前的条件判断结构，不会执行其以下的条件结构语句。
2.如果诸多个条件表达式之间“互斥”关系，多个结构可以上下调换顺序
如果诸多个条件表达式之间“包含”关系，要求条件表达式范围小的写在范围大的上面。
2.选择结构
switch(变量){
case 值1:
//break;
case 值2:
//break;
……
default:
break;
}
【注意】
1.变量可以为如下的数据类型：byte short int char 枚举 String
2.case后只能填写变量的值，不能写范围。
3.default是可以省略的。并且其位置也是灵活的，但是通常将其放在case语句之后。
4.一旦满足某个case语句，则进入执行其操作。直到遇到break或者程序终止。
5.若要判断的语句的条件满足switch变量的数据类型，且值不多的情况下，建议选择switch-case.
除此之外，选择if-else.
3.循环结构：
1.格式：
①初始化条件
②循环条件
③迭代部分
④循环体
①
while(②){
④
③
}
①
do{
④
③
}while(②)
for(①;②;③){
④
}
注：1.不同的循环结构之间可以相互转换
2.while和do-while的区别：do-while程序至少会执行一次
2.嵌套循环：循环结构还可以声明循环。让内层循环结构整体充当外层循环的循环体。
若外层循环执行m次，内层循环执行n次，整个程序执行m*n次。
【题目】
******
******
******
for(int i = 0; i < 3; i++){
for(int j = 0; j < 6; j++){
System.out.print("*");
}
System.out.println();
}
说明：外层循环
控制行数，内层循环控制列数
【例题】1.九九乘法表 2.输出100内的质数。（两种）
3.无限循环
for(;;){
...
if(){
break;
}
...
}
或者
while(true){
...
if(){
break;
}
...
}
往往我们在无限循环结构内部提供循环的终止条件，使用break关键字。否则，此循环将无限制的执行下去，形成死循环！
死循环是我们要避免的。
4.break&continue
break:
>使用switch-case结构或者循环结构中
>在循环结构中，一旦执行到break，就跳出当前循环。
continue:
>使用在循环结构中
>一旦执行到continue，就跳出当次循环。
for(int i = 1; i <= 10; i++){
if(i % 4 == 0){
//break;//123
continue;//123567910
}
System.out.print(i);
}
在嵌套循环中，使用带标签的break和continue。
label:for(int i = 1; i < 5; i++){
for(int j = 1; j <= 10; j++){
if(j % 4 == 0){
//break;
//continue;
//break label;
continue label;
}
System.out.print();
}
System.out.println();
}
五、数组
数组：相同数据类型的数据的组合。
如：int score = 72;
int score1 = 90;
int socre2 = 59;
使用数组：
1.数组的初始化
int scores[] = new int[]{72,90,59};//静态初始化：在声明并初始化数组与给数组相应的元素赋值操作同时进行。
int scores1[] = new int[3];//动态初始化：在声明并初始化数组与给数组相应的元素赋值操作分开进行。
scores1[0] = 72;
scores1[1] = 90;
scores1[2] = 59;
//声明数组的错误写法：
1）String[] names = new String[5]{"AA", "BB", "CC"};
2）int i[10];
3）int i = new int[];
注：不管是动态还是静态初始化数组，一定在创建的时候，就指明了数组的长度！
2.如何引用数组元素：通过数组的下角标的方式。下角标从0开始，到n - 1结束。其中为数组的长度。
3.数组的长度：通过数组的属性length来调用。
System.out.println(scores1.length);//3
4.如何遍历数组
for(int i = 0; i < scores.length; i++){
System.out.println(scores[i]);
}
5.判断数组元素的默认初始化值
1)byte short int long 而言：0
2)float double而言：0.0
3)char而言：空格
4)boolean而言：false
5)引用类型变量而言：null
6.数组的内存结构
二维数组
1.声明并初始化
//一维
int i[] = new int[12];
i[0] = 12;
int j[] = new int[]{12, 3};
//二维:
1)String str[][] = new String[4][3];//4行3列
2)String str1[][] = new String[4][];
str1[0] = new String[3];
...
str[3] = new String[5];
3)
int arr[][] = new int[][]{{1, 2, 3}, {4, 5}, {6}};
2.如何引用二维数组的元素：arr[1][0] = 12;
3.二维数组的长度：arr.length;//3
arr[1].length;//2
4.遍历二维数组
for(int i = 0; i < arr.length; i++){
for(int j = 0; j < arr[i].length; j++){
System.out.print(arr[i][j]+"\t");
}
Syst
em.out.println();
}
5.二维数组的结构：
数组的异常：
数组下标越界的异常：https://www.360docs.net/doc/b3147954.html,ng.ArrayIndexOutOfBoundsException
int i[] = new int[10];
i[0] = 90;
i[10] = 99;
空指针的异常：NullPointerException
第一种：
boolean b[] = new boolean[3];
b = null;
System.out.println(b[0]);
第二种：
String str[] = new String[4];
str[3] = new String("AA");//str[3] = "AA";
System.out.println(str[3].toString());
第三种：
int j[][] = new int[3][];
j[2][0] = 12;
数组的常用的算法问题
1.求数组的最大值、最小值、总和、平均数
2.数组的复制和反转
情况1：
情况2：（如何实现复制）
数组的反转：
数组元素的反转
for(int i = 0; i < arr.length / 2; i++){
int temp = arr[i];
arr[i] = arr[arr.length - 1 - i];
arr[arr.length - 1 - i] = temp;
}
for(int x = 0, y = arr.length - 1; x < y; x++, y--){
int temp = arr[x];
arr[x] = arr[y];
arr[y] = temp;
}
扩展：String str = "abcdefg";
数组的排序：
插入排序
直接插入排序、折半插入排序、Shell排序
交换排序
冒泡排序、快速排序（或分区交换排序）
选择排序
简单选择排序、堆排序
归并排序
基数排序
//使用冒泡排序使数组元素从小到大排列
for(int i = 0; i < arr.length - 1; i++){
for(int j = 0; j < arr.length - 1 - i; j++){
if(arr[j] > arr[j + 1]){
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
//使用直接选择排序使数组元素从小到大排列
for(int i = 0; i < arr.length; i++){
int t = i;
for(int j = i; j < arr.length; j++){
if(arr[t] > arr[j]){
t = j;
}
}
if(t != i){
int temp = arr[t];
arr[t] = arr[i];
arr[i] = temp;
}
}
还可以调用：Arrays工具类：arrays.sort(arr);