前面只是对java的一次初见，本篇将是对java一次较为全面的认识与使用。都是一些需要注意，容易遗忘的坑。了解一下。
关键字 & 标识符
- 关键字：被Java语言赋予了特殊含义，用做专门用途的字符串（单词）
- 保留字：被java语言提前定义下，现在没有使用，之后可能会占用
- 标识符：凡是自己可以起名字的地方都叫标识符
命名的规则
一定要遵守，不遵守就会报编译的错误
- 由26个英文字母大小写，0-9 ，_或 $ 组成
- 数字不可以开头。
- 不可以使用关键字和保留字，但能包含关键字和保留字。
- Java中严格区分大小写，长度无限制。
- 标识符不能包含空格。
Java中的名称命名规范
不遵守，也不会出现编译的错误
- 包名：多单词组成时所有字母都小写：xxxyyyzzz
- 类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz
- 变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz
- 常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ
变量
- java中变量按照数据类型来分类：基本数据类型 vs 引用数据类型(数组 类 接口)
基本数据类型：
- 整型：byte（8 bit） short int（默认类型） long
- 浮点型：float double (默认类型)
- 字符型：char（‘ ’）
- 布尔类型： boolean（只能取值为true 或false，不能取null）
补充：按照在类中存在的位置的不同：成员变量 vs 局部变量
进制（了解）
- 十进制、二进制、八进制、十六进制
二进制：计算机底层都是用二进制来存储、运算。
二进制在底层存储：正数、负数都是以补码的形式存储的。（原码、反码、补码）
变量的运算
①自动类型转换：容量小的数据类型自动转换为容量大的数据类型。
short s = 12;
int i = s + 2;
//注意：byte short char之间做运算，结果为int型！②强制类型转换：是①的逆过程。使用“（）”实现强转。
运算符
- 运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。
算术运算符
+ - + - * / % ++ -- +
注意：1） /: int i = 12; i = i / 5;
2） %：最后的符号只跟被模数相同
3）前++：先+1，后运算 后++：先运算，后+1
4）+：String字符串与其他数据类型只能做连接运算，且结果为String类型。sysout('*' + '\t' + '*'); vs sysout("*" + '\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){}逻辑运算符
- 运算符的两端是boolean值
& && | || ^ !
【注意】区分 & 与 && 的区别，以及 | 与 || 的区别
我们使用的时候，选择&& ， ||位运算符
- 两端是数值类型的数据
<< >> >>> & | ^ ~
【例子】1.如何交换m = 12和n = 5的值
2.将60转换为十六进制输出。三元运算符
- (条件表达式)？ 表达式1 ： 表达式2；
1）既然是运算符，一定会返回一个结果，并且结果的数据类型与表达式1，2的类型一致
2）表达式1与表达式2 的数据类型一致。
3）使用三元运算符的，一定可以转换为if-else。反之不一定成立。
例子：获取两个数的较大值；获取三个数的最大值。
流程控制
顺序结构
- 程序从上往下的顺序执行
分支结构
- 条件判断
1. if(条件表达式){ }
2. if(条件表达式){
//执行的语句1；
}else{
//执行的语句2；
}
3. if(条件表达式1){
//执行的语句1；
}else if(条件表达式2){
//执行的语句2；
}else if( 条件表达式3){
//执行的语句3；
}...
}else{
//执行的语句；
}
【注意】
- 一旦满足某个条件表达式，则进入其执行语句块执行，执行完毕，跳出当前的条件判断结构，不会执行其以下的条件结构语句。
- 如果诸多个条件表达式之间为“互斥”关系，多个结构可以上下调换顺序
- 如果诸多个条件表达式之间为“包含”关系，要求条件表达式范围小的写在范围大的上面。
- 选择判断
switch(变量){
case 值1:
//break;
case 值2:
//break;
...
default:
break;
}
【注意】
- 变量可以为如下的数据类型：byte short int char 枚举 String
- case后只能填写变量的值，不能写范围。
- default是可以省略的。并且其位置也是灵活的，但是通常将其放在case语句之后。
- 一旦满足某个case语句，则进入执行其操作。直至遇到break或者程序终止。
- 若要判断的语句的条件满足switch变量的数据类型，且值不多的情况下，建议选择switch-case . 除此之外，选择if-else.
循环结构
格式：
1. 初始化条件
2. 循环条件
3. 迭代部分
4. 循环体
for(1;2;3){
4
}
//--------分割----------
1
while(2){
4
3
}
//--------分割----------
1
do{
4
3
}while(2);
//注： 1.不同的循环结构之间可以相互转换
// 2.while和do-while的区别：do-while程序至少会执行一次- 嵌套循环
循环结构还可以声明循环。让内层循环结构整体充当外层循环的循环体。若外层循环执行m次，内层循环执行n次，整个程序执行m*n次。
for(int i = 0;i < 3;i++){
for(int j = 0;j < 6;j++){
System.out.print("*");
}
System.out.println();
}
//说明：外层循环控制行数，内层循环控制列数- 无限循环结构
for(;;){
...
if( ){
break;
}
...
}
或者
while(true){
...
if( ){
break;
}
...
}往往我们在无限循环结构内部提供循环的终止条件，使用break关键字。否则，此循环将无限制的执行下去，形成死循环！
死循环是我们要避免的。
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; ---- NO
//continue;---- NO
//break label; ----- YES
//continue label;----- YES
}
System.out.print(j);
}
System.out.println();
}数组
相同数据类型的数据的组合。
如： int score1 = 72;
int score2 = 90;
int score3 = 59;
数组的初始化
int[] scores1 = new int[]{72,90,59};//静态初始化：在声明并初始化数组与给数组相应的元素赋值操作同时进行。
int scores2[] = new int[3];//动态初始化：在声明并初始化数组与给数组相应的元素赋值操作分开进行。
scores2[0] = 72;
scores2[1] = 90;
scores2[2] = 59;
//声明数组的错误写法：
// 1）String[] names = new String[5]{"AA","BB","CC"};
// 2）int i[10];
// 3）int i = new int[];
//注：不管是动态还是静态初始化数组，一定在创建的时候，就指明了数组的长度！数组的引用
- 通过数组的下角标的方式。下角标从0开始，到n-1结束。其中n为数组的长度。
数组的长度
- 通过数组的属性length来调用。
System.out.println(scores2.length);//输出3数组的遍历
for(int i = 0;i < scores1.length;i++){
System.out.println(scores1[i]);
}数组的始化值
- 关于数组元素的默认初始化值
1) byte short int long 而言：0
2) float double 而言：0.0
3) char而言：空格
4) boolean而言：false
5) 引用类型变量而言:null
二维数组
- 声明并初始化
//一维：
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];
...
str1[3] = new String[5];
3) int[][] arr = new int[][]{{1,2,3},{4,5},{6}};- 引用二维数组的元素
arr[1][0] = 12;- 二维数组的长度
arr.length;//3
arr[1].length;//2- 遍历二维数组
for(int i = 0;i < arr.length;i++){
for(int j = 0;j < arr[i].length;j++){
System.out.print(arr[i][j] + "\t");
}
System.out.println();
}数组的常见异常
//1.数组下标越界的异常:java.lang.ArrayIndexOutOfBoundsException
int[] i = new int[10];
// i[0] = 90;
// i[10] = 99;
// for(int m = 0;m <= i.length;m++){
// System.out.println(i[m]);
// }//2.空指针的异常：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;数组的排序
- 插入排序 -- 直接插入排序、折半插入排序、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 - 1; i++){
int t = i;//默认i处是最小的
for(int j = i;j < arr.length;j++){
//一旦在i后发现存在比其小的元素，就记录那个元素的下角标
if(arr[t] > arr[j]){
t = j;
}
}
if(t != i){
int temp = arr[t];
arr[t] = arr[i];
arr[i] = temp;
}
}到此先休息一下，后面还有好多的内容。下一篇主要是面向对象的超多内容。
版权属于：ic翼
本文链接：https://bingyishow.top/Technical-article/41.html
您必须遵守 署名-非商业性使用-相同方式共享 CC BY-NC-SA 使用这篇文章
