Java学习笔记02（持续更新）
文章目录
- 2.1 注释和编码规范
- 2.1.1 注释
- 2.1.2 编码规范
- 2.2 流程控制
- 2.2.1 顺序结构
- 2.2.2 分支结构
- 2.2.3 循环结构
- 2.2.4 特殊控制语句
- 2.3 数组
- 2.3.1 一维数组
- 2.3.2 二维数组
- 2.3.2 字符串数组
- 2.3.4 数组操作
- 2.3.5排序算法
- 2.3.6. 二分查找法
- 2.4 符号常量的定义
- 2.5 数据的标准输入与输出
- 2.5.1 输入
- 2.5.2 输出
- 2.5 Math 库的基本使用
- 2.6 方法
- 2.6.1 方法的定义
- 2.6.2 方法的调用
- 2.6.3 方法的重载
本专栏其他文章：
JDK安装配置
eclipse安装与使用
Java学习笔记01
Java学习笔记03
2.1 注释和编码规范
2.1.1 注释
Java语言提供了3种添加注释的方法，分别为单行注释、多行注释和文档注释。
单行注释和多行注释和c语言中一致，文档注释是Java特有的。
单行注释
// ......
多行注释
/*
...
...
*/
文档注释
/**
* ...
* ...
* ...
*/
2.1.2 编码规范
在学习开发的过程中要养成良好的编码规范，规整的代码格式会给程序的开发与日后的维护提供很大方便。总结的编码规范如下：
- 每条语句要单独占一行
- 每条命令都要以分号结束
- 声明变量时要分行声明
- Java语句中多个空格看成一个
- 不要使用技术性很高、难懂、易混淆判断的语句
- 对于关键的方法要多加注释
2.2 流程控制
这部分和C语言中是完全相同的，不详细些写了。
2.2.1 顺序结构
程序每个语句都是从上到下地被执行，中间没有任何的判断和跳转。
2.2.2 分支结构
分支结构包括 if-else 和 switch 两种分支语句。
1. if-else
if条件语句用于告诉程序在某个条件成立的情况下执行某段程序，而在另一种情况下执行另外的语句。
使用if条件语句，可选择是否要执行紧跟在条件之后的那个语句。关键字if之后是作为条件的“布尔表达式”，如果该表达式返回的结果为true，则执行其后的语句；若为false，则不执行if条件之后的语句。
if条件语句可分为简单的if条件语句、if…else语句和if…else if多分支语句。
三种主要格式
1.
if(true)
{
执行语句;
}
2.
if(条件表达式)
{
执行语句;
}
else
{
执行语句;
}
3.
if(条件表达式)
{
执行语句;
}
else if(条件表达式)
{
执行语句：
}
else
{
执行语句：
}
在if-else语句中也可以嵌套使用，即if套if（禁止套娃）。
2. switch
switch语句中表达式的值必须是整型或字符（串）型，case后值的必须是常量。switch语句首先计算表达式的值，如果表达式的值和某个case后面的变量值相同，则执行该case语句后的若干个语句直到遇到break语句为止。此时如果该case语句中没有break语句，将继续执行后面case里的若干个语句，直到遇到break语句为止。若没有一个常量的值与表达式的值相同，则执行default后面的语句。default语句为可选的，如果它不存在，而且switch语句中表达式的值不与任何case的常量值相同，switch则不做任何处理。
语法：
switch（变量）{
case 常量1:
语句1;
break;
case 常量2:
语句2;
break;
...
case 常量n:
语句n;
break;
default:
语句;
break;
}
2.2.3 循环结构
在Java中，循环结构有3种 while 、for、do…while。
1. while
while语句也称条件判断语句，它的循环方式为利用一个条件来控制是否要继续反复执行这个语句，语法如下所示：
while(条件表达式)
{
执行语句;
}
当条件表达式的返回值为真时，则执行{}中的语句，当执行完{}中的语句后，重新判断条件表达式的返回值，直到表达式返回的结果为假时，退出循环。
2.do…while
do…while循环语句与while循环语句类似，它们之间的区别是while语句为先判断条件是否成立再执行循环体，而do…while循环语句则先执行一次循环后，再判断条件是否成立。也就是说do…while循环语句中大括号中的程序段至少要被执行一次，语法如下所示：
do {
执行语句
}
while(条件表达式);
与while语句的一个明显区别是do…while语句在结尾处多了一个分号（;）。
3. for
一个for循环可以用来重复执行某条语句，直到某个条件得到满足。
语法如下所示：
for(表达式1;表达式2;表达式3) {
语句序列
}
表达式1：初始化表达式，负责完成变量的初始化。
表达式2：循环条件表达式，值为boolean型的表达式，指定循环条件。
表达式3：循环后操作表达式，负责修整变量，改变循环条件。
循环可以嵌套使用，以for循环为例，
以二层循环举例说明
int i;
int j;
int n;
int m;
for(i=0;i<n;i++)
for(j=0;j<m;j++)
建议把小循环放在外层，大循环放在内层。
2.2.4 特殊控制语句
1. continue
用于跳过某个循环语句的一次执行，进入下一次循环
2. break
直接终止当前所在循环，或者用在switch语句中终止case的语句。
3. return
return不是用来终止循环的，而是用来结束一个方法。当一个方法读取到return 语句时，方法会直接被终止不管这个语句的位置在哪。
2.3 数组
Java中的数组和C语言中的数组有所不同。
数组是具有相同数据类型的一组数据的集合。数组中的每个元素具有相同的数据类型。可根据数组的维数将数组分为一维数组、二维数组……
2.3.1 一维数组
在使用数组之前，必须首先定义数组变量所属的类型，即声明数组，声明一维数组有两种形式，语法如下：
数组元素类型 数组名字[ ];
数组元素类型[ ] 数组名字;
int arr[];
int[] arr;
数组元素类型：决定了数组的数据类型，它可以是Java中任意的数据类型。
数组名字：为一个合法的标识符
符号“[ ]”：指明该变量是一个数组类型变量，单个“[ ]”表示创建的数组是一维数组
数组可以与基本数据类型一样进行初始化操作，数组的初始化可分别初始化数组中每个元素。数组的初始化有两种形式。
如下所示：
动态初始化：
int arr1[] = new int[]; //第一种初始化方式
静态初始化：
int arr2[] = {1,2,3,4}; //第二种初始化方式
数组的初始化方式是：把数据类型包括在大括号之内，中间用逗号分开数组元素的值，系统自动为数组分配一定的空间。
数组中的内容可以用元素下标引用。元素下标就是该元素处于第几位。
注意：元素下标是从左到右从0开始。
例如，上面初始化的数组arr2中，第一个元素是 1 ，其元素下标为0，即
a[0] == 1;
后面的元素也是如此。
在Java中获取数组的长度比较容易可以直接使用 .length ，例如：
int[] arr = {1,2,3,4};
int len = arr.length(); //此时的 len = 4
2.3.2 二维数组
声明二维数组的方法有两种，语法如下所示：
数组元素类型 数组名字[ ][ ];
数组元素类型[ ][ ] 数组名字;
int arr[][];
int[][] arr;
数组元素类型：决定了数组的数据类型，它可以是Java中任意的数据类型。
数组名字：为一个合法的标识符
符号“[ ]”：指明该变量是一个数组类型变量，两个“[ ]”表示创建的数组是二维数组。
还有一种特殊写法：
int[] x,y[]; 这种定义方式 x为一维数组， y为二维数组
还可以只定义一维的长度，不定义二维的长度:
int[][] arr = new int[2][];
二维数组的初始化同一维数组初始化类似，同样可以使用大括号完成二维数组的初始化。语法如下所示：
动态初始化：
int arr1[][] = new int[2][3]; //第一种初始化方式
静态初始化：
int[][] arr2 = {
{1,2},
{3,4},
{5,6},
}; //第二种初始化方式
二维数组的下标也是从0,0开始的（可以把二维数组想象成矩阵）。
根据上面初始化的数组，
arr2[0][0] == 1;
获取二维数组的长度和一维数组的方式相似。
int arr1[][] = new int[2][3]{
{1,2},
{3,4},
{5,6},
};
int len1 = arr.length;//获取一维长度
int len2 = arr[].length;//获取二维长度
2.3.2 字符串数组
字符串数组是指构成数组的元素是字符串类型。
声明格式：
String[] 数组名;
String 数组名[];
创建格式：
数组名 = new String[个数];
元素赋值：
数组名[下标] = "字符串";
例如：
String[] b;
b = new int[3];
b[0] = "abc";
b[1] = "bcd";
b[2] = "cde";
2.3.4 数组操作
Arrays.toString()
/**
* @param a 数组
* @return 数组中的内容的字符串形式
*/
public static String toString(int[] a)
Arrays.copyOf()
/**
* 把源数组复制到一个新的指定长度的数组中并返回新数组
* @param original 要复制的数组
* @param newLength 要返回的副本的长度
* @return 原始数组的副本，被截断或用零填充以获得指定的长度
*/
public static int[] copyOf(int[] original,
int newLength)
System.arraycopy()
/**
* 将指定源数组中的数组从指定位置复制到目标数组的指定位置
* @param src 要复制的源数组
* @param srcPos 源数组的起始位置
* @param dest 目标数组（要复制到的数组）
* @param destPos 目标数组的起始位置
* Wparam length 要复制的长度
*/
public static void arraycopy(Object src,
int srcPos,
Object dest,
int destPos,
int length)
Array.sort()
/**
* 对数组排序
* @param a 要排序的数组
*/
public static void sort(int[] a)
2.3.5排序算法
1.冒泡排序
for (int i = 0; i < nums.length - 1; i++) {
for (int j = 0; j < nums.length - i - 1; j++) {
if (nums[j] < nums[j + 1]) {
int temp = nums[j];
nums[j] = nums[j + 1];
nums[j + 1] = temp;
}
}
}
2.选择排序
for (int i = 0; i < nums.length; i++) {
int minIndex = i;
for (int j = i + 1; j < nums.length; j++) {
if (nums[j] < nums[minIndex]) {
minIndex = j;
}
}
if (minIndex != i) {
int temp = nums[minIndex];
nums[minIndex] = nums[i];
nums[i] = temp;
}
}
3. 高效选择排序
int count = nums.length;
for (int i = 0; i < count; i++) {
int min = i;
int max = count -1;
for (int j = i; j < count; j++) {
if (nums[j] < nums[min]) {
min = j;
}
if (nums[j] > nums[max]) {
max = j;
}
}
if (min != i) {
int temp = nums[i];
nums[i] = nums[min];
nums[min] = temp;
if (max == i) {
max = min;
}
}
if (max != count -1) {
int temp = nums[count - 1];
nums[count - 1] = nums[max];
nums[max] = temp;
}
count--;
}
2.3.6. 二分查找法
前提：
数组已排序好
基本原理：
首先将要查找的元素（key）与数组的中间元素比较
如果key小于中间元素，只需要在数组的前一半元素中继续查找
如果key和中间元素相等，匹配成功，查找结束
如果key大于中间元素，只需要在数组的后一半元素中继续查找
Arrays.sort(nums);
int low = 0;
int high = nums.length - 1;
int mid = (low + high) / 2;
// int searchNum = ...;
int searchIndex = -1;
while (low <= high) {
mid = (low + high) / 2;
if (searchNum > nums[mid]) {
low = mid + 1;
} else if (searchNum < nums[mid]) {
high = mid - 1;
} else {
searchIndex = mid;
break;
}
}
2.4 符号常量的定义
常量顾名思义就是不可改变的量，一经定义就不可再改变其值
定义格式：
final 类型 常量名 = 常量值；
final int N = 100;
final double PI = 3.14;
常量命名习惯上所有字母全使用大写的
2.5 数据的标准输入与输出
2.5.1 输入
在Java中实现数据输入有一点点麻烦，需要先用Scanner类构建一个“扫描器”。
格式：Scanner 名称 = new Scanner(System.in);
注意在使用Scanner类时，需要使用语句“import java.util.Scanner”来导入Scanner类
然后通过通道输入数据，但是数据类型不同，使用的方法就不同
| 名称 | 功能 |
|---|---|
| next() | 输入一个字符串 |
| nextByte() | 输入一个字节型整数 |
| nextShort() | 输入一个短整型数 |
| nextInt() | 输入一个整数 |
| nextLong() | 输入一个长整型数 |
| nextFloat() | 输入一个单精度浮点数 |
| nextDouble() | 输入一个双精度浮点数 |
| nextBoolean() | 输入一个布尔类型的量 |
| nextLine() | 读入一行数据 |
例如：
import java.util.Scanner;
public class Test{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int x = sc.nextInt(); //输入int型数据
float f = sc.nextFloat();//输入 float 型数据
String S = sc.nextLine();//输入一行数据
}
}
2.5.2 输出
相对于输入来说，输出要简单一些。
Java通过 System.out 提供的 print() 和 println() 方法来输出数据。
格式：
System.out.print();
System.out.println();
例如：
System.out.println("123");
System.out.print("456");
2.5 Math 库的基本使用
在Java中，JDK提供了一个关于数学计算的类库，下面就来介绍常用的数学方法。
| 名称 | 功能 |
|---|---|
| random() | 随机产生一个 0.1 ~ 1.0 之间的双精度浮点数 |
| abs(x） | 返回X的绝对值 |
| sqrt(x) | 返回x的平方根 |
| pow(x，y) | 返回 xy的值 |
| exp(x) | 返回ex的值 |
| log(x) | 返回以e为底x的对数 |
| log10(x) | 返回以10为底x的对数 |
| floor(x) | 返回小于或等于x，并且与之最接近的整数 （向下取整） |
| ceil(x) | 返回大于或等于x，并且与之最接近的整数（向上取整） |
| round() | 四舍五入取整，返回与x最接近的整数 |
例如：
double d = random（）;
int x = sqrt(9); //值为3
int a = floor(3.2);//值为3
int b = ceil(3.2);//值为4
int c = round(3.2);//值为3
2.6 方法
2.6.1 方法的定义
Java方法只能定义在类内，不能嵌套定义在方法内。
格式：
[修饰符] [static] <方法返回值类型> <方法名> (参数列表) {
方法体;
}
其中，
修饰符: 可选项，用于指定访问权限，有 public、protected、private。
static: 可选项，定义的方法为静态方法。若没有则定义的是实例方法。
返回值类型： 必选项，用于指定方法的返回值，若无返回值，则用void。
方法名： 必选项，就是自定义方法名（必须合法）。
参数列表： 可选项，指定方法中的参数。有多个时，用逗号隔开。
方法体： 函数的实现部分，用大括号括起来。
2.6.2 方法的调用
Java方法有两种：静态方法和实例方法（定义时有无static）。
1. 静态方法
静态方法又称为类方法，通过类名调用。
调用形式：
类名.方法名(实参列表)；
2. 实例方法
实例方法又称为对象方法，通过对象名调用。
调用形式：
对象名.方法名(参数列表)；
2.6.3 方法的重载
方法重载就是在一个类中出现了同名，但是参数数目或者类型不同的方法。
在执行时，根据方法参数的数目和类型选择哪个执行。
例如：
void show (int a){};
void show (double a){};
void show (int a, double b){};
本博客用于记录本人Java的学习过程，本人才疏学浅，如有错误，请在评论区指出