Java学习笔记02（持续更新）

本博客用于记录本人Java的学习过程，本人才疏学浅，如有错误，请在评论区指出

本专栏其他文章：
JDK安装配置
eclipse安装与使用
Java学习笔记01
Java学习笔记03
Java学习笔记04
JDBC技术

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){};