Java基础语法（三）
Java基础语法（三）
不积跬步，无以至千里；不积小流，无以成江海。 ——荀子《劝学》
十六、方法
-
方法的概念：执行一个功能的执行语句的集合，类似于其它语言的函数。
-
方法包含于类或者对象中。
-
方法的定义：
修饰符 返回值类型 方法名(参数类型 参数名){ ... 方法体 ... return 返回值; }-
修饰符：可选的，定义了该方法的类型。
-
返回值类型：用于限定方法返回值的数据类型。
-
方法名：方法的实际名称。
-
参数类型：用于限定调用方法时传入参数的数据类型。参数是可选的，方法可以不包含任何参数。
参数又分为形式参数（形参）和实际参数（实参）。
形参：在方法被调用时用于接受外界输入的数据。
实参：调用方法时实际传给方法的数据。
-
方法体：具体执行功能的代码语句。
-
-
方法的重载（重要）（以免跟后面方法的重写混淆
重载就是在一个类中，有相同的方法名称，但形参不同的函数。
方法的重载规则：
- 方法的名称必须相同。
- 参数列表必须不同（参数个数不同、或者参数类型不同、或者参数的排列顺序不同等）
- 方法的返回类型可以相同可以不同。
- 仅仅是返回类型不同不足以称为方法的重载。
方法重载的原理：
方法名称相同时，编译器会根据调用方法的参数个数、参数类型逐一匹配，一选择对应的方法。如果匹配失败，则编译器报错。
例子：
public class demo1 {
public static void main(String[] args) {
int sum1 = add(1,2);
int sum2 = add(1,2,3);
double sum3 = add(1,2);
System.out.println(sum1);
System.out.println(sum2);
System.out.println(sum3);
}
public static int add(int x, int y){
return x + y;
}
//add方法参数个数不同方法重载
public static int add(int x, int y, int z){
return x + y + z;
}
//add方法参数类型不同方法重载
public static double add(double x, double y){
return x + y;
}
}
输出结果：
3
6
3.0
十七、命令行传参（扩展）
- 有时候希望运行一个程序时再传递给它消息，就要靠传递命令行参数给 main() 函数实现。
package javase.method;
public class demo1 {
public static void main(String[] args) {
for (int i = 0; i < args.length; i++) {
System.out.println("args[" + i + "]:" + args[i]);
}
}
}
在该 Java 文件目录下使用命令行窗口进行编译：
可以看到可以编译，得到demo1.class文件。
接着在该路径下运行：
发现会报找不到或无法加载主类，原因是我们这个是在包里的，要将路径回退到包所在的上一个路径才能运行 .class 文件，找到主类。
回退到 src 路径下要执行 包名+文件名 的完整路径才能正常运行，否则还是执行不了。
接着在执行命令里面传递参数，结果如下：
十八、可变参数（扩展）（本质：数组）
- JDK1.5开始，Java支持传递同类型的可变参数给一个方法。
- 在方法声明中，在指定参数类型后加一个省略号（...）。
- 一个方法中只能指定一个可变参数，它必须是方法的最后一个参数，任何普通参数必须在它之前声明。
public class demo2 {
public static void main(String[] args) {
max(1,2,3,4,5);
max(5.2,9.9,3.14);
}
public static void max(double... num){
if(num.length == 0){
System.out.println("没有参数。");
return;
}
double result = num[0];
for(int i = 1; i < num.length;i++){
if(num[i] > result){
result = num[i];
}
}
System.out.println(result);
}
//public static void max(double... num,int b)报错，可变参数只能是方法最后一个参数
}
输出：
5.0
9.9
十九、递归
-
递归：A方法调用A方法。
-
递归结构包括两个部分：
- 递归头：什么时候不调用自身方法，如果没有将陷入死循环。
- 递归体：什么时候需要调用自身方法。
-
优点：大大减少代码量，用有限的语句来定义对象的无限集合。
-
缺点：容易陷入死循环和造成栈溢出。（
java.lang.StackOverflowError），所以一般不推荐使用。 -
例子：求比较小的数的阶乘。
public class demo3 { public static void main(String[] args) { int result = f(6); System.out.println(result); } public static int f(int n){ if(n == 1){ return 1; }else{ return n * f(n-1); } } }输出： 720
二十、数组
（一）数组的定义：
数组是相同类型数据的有序集合，数组中的每个数据称为元素，每个数组元素可以通过一个下标来访问它们。
数组可以存放任意类型的元素，但是同一个数组里存放的元素类型必须相同。
（二）数组的声明创建
首先必须先声明数组变量，才能在程序中使用数组，声明数组的语法：
dataType[] arr; //最好使用
或者
dataType arr[];
Java语言使用 new 操作符来创建数组，语法：
dataType[] arr = new dataType[arraySize];
数组的元素是通过索引访问的，数组索引从 0 开始。
获取数组的长度：arr.length
（三）数组的初始化
-
动态初始化：在定义数组时，只指定数组的长度，由系统自动为元素赋初值的方法，后面可以自己修改元素值。
//动态初始化 int[] a = new a[3]; a[0] = 1; a[1] = 2 -
静态初始化：在定义数组的同时就为数组的每个元素赋值。
/*静态初始化数组的两种方法 1.类型[] 数组名 = new 类型[]{元素值1，元素值2，...}; 2.类型[] 数组名 = {元素值1，元素值2，...}; */ int[] b = new int[]{1,2,3}; int[] c = {1,2,3}; -
动态初始化数组元素默认值：
- 整数类型：0
- 浮点数类型：0.0
- char：一个空字符，即 ’ \u0000 '（注意：不是空格）
- boolean：false
- 引用数据类型：null
（四）Java内存分析
（五）数组的四个基本特点
-
其长度是确定的。数组一旦被创建，它的大小就不可以改变。
-
一个数组的元素必须是相同类型的，不允许出现混合类型。
-
数组中的元素可以是任何数据类型，包括基本类型和引用类型。
-
数组变量属于引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中。
（六）数组的边界
下标（索引）的合法区间 [ 0 , length - 1 ]，如果越界就会报错！
ArrayIndexOutOfBoundsException：数组下标越界异常！
（七）多维数组
-
多维数组可以看成数组的数组，比如二维数组就像是一个特殊的一维数组，其每一个元素都是一个一维数组。
-
二维数组的定义：
//1. 动态初始化1.arr是一个两行三列的数组，arr是一个两行三列的数组 int[][] arr = new int[2][3]; arr[0][1] = 0; ...... //2. 动态初始化2 int[][] arr = new int[2][]; //只声明行数，不声明列数 //3. 静态初始化 int[][] arr = new int[][]{{1,2},{3,4,5,6},{7,8,9}}; int[][] arr = {{1,2},{3,4,5,6},{7,8,9}}; //错误情况： String[][] arr = new String[][4]; //只声明列数，不声明行数 String[4][3] arr = new String[][]; int[][] arr = new int[4][4]{{1,2},{3,4,5,6},{7,8,9}}; -
二维数组可以只声明行数，不能只声明列数的原因：
与数组创建的内存有关。
（八）数组的应用——Arrays类
-
数组的工具类：java.util.Arrays
-
Arrays类中的方法都是 static 修饰的静态方法，在使用的时候可以直接使用类名进行调用，而不用使用对象来调用（注意：是“不用”而不是“不能”）。
-
常用功能：
- 给数组赋值：通过 fill 方法。
- 对数组排序：通过 sort 方法。
- 比较数组：通过 equals 方法比较数组中的元素值是否相等。
- 查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找法操作。
- 打印数组：通过 toString 方法。
-
例子
import java.util.Arrays; public class demo1 { public static void main(String[] args) { int[] a = {11,5,6,1,85,64,33}; System.out.println(Arrays.toString(a)); Arrays.sort(a); System.out.println(Arrays.toString(a)); Arrays.fill(a,0); System.out.println(Arrays.toString(a)); Arrays.fill(a,2,4,1); //数组下标[2，4）区间的元素填充值 1 System.out.println(Arrays.toString(a)); } }
输出结果：
[11, 5, 6, 1, 85, 64, 33]
[1, 5, 6, 11, 33, 64, 85]
[0, 0, 0, 0, 0, 0, 0]
[0, 0, 1, 1, 0, 0, 0]
（九）稀疏数组（扩展）
-
当一个数组中大部分元素为 0 ，或者大部分元素为同一值的数组时，可以使用稀疏数组来保存该数组。
-
稀疏数组的处理方式：
- 记录数组一共有几行几列，有多少不同的值。
- 把具有不同值元素的行列下标及值记录在一个小规模的数组中，从而缩小程序的规模。
-
例子：
左边为原始数组，后边为稀疏数组。
稀疏数组的第一行记录数组一共有几行几列，有多少个不同的值。
接下来几行就是记录不同值元素的行下标、列下标及值。
public class demo2 {
public static void main(String[] args) {
//创建一个二维数组
int[][] arr1 = new int[6][7];
//向二维数组里放值
arr1[0][3] = 22;
arr1[0][6] = 15;
arr1[1][1] = 11;
arr1[1][5] = 17;
arr1[2][3] = -6;
arr1[3][5] = 39;
arr1[4][0] = 91;
arr1[5][2] = 28;
//打印二维数组
System.out.println("打印二维数组");
for (int i = 0; i < arr1.length; i++) {
for (int j = 0; j < arr1[0].length; j++) {
System.out.print(arr1[i][j] + " ");
}
System.out.println();
}
//二位数组----->稀疏数组
//遍历二维数组中有效值的个数,用sum来记录
int sum = 0;
for (int i = 0; i < arr1.length; i++) {
for (int j = 0; j < arr1[0].length; j++) {
if (arr1[i][j] != 0){
//二维数组中元素不为0即为有效值
sum++;
}
}
}
//创建稀疏数组
//行数为sum+1，第一行用于保存二维数组的行列及有效值个数，列数固定为3
int[][] sparseArr = new int[sum + 1][3];
//存入二维数组的行列及有效值个数
sparseArr[0][0] = arr1.length;
sparseArr[0][1] = arr1[0].length;
sparseArr[0][2] = sum;
//再次遍历二维数组，将有效值存入稀疏数组
//用于保存稀疏数组的行数
int count = 1;
for (int i = 0; i < arr1.length; i++) {
for (int j = 0; j < arr1[0].length; j++) {
if (arr1[i][j] != 0) {
//将值存入稀疏数组
sparseArr[count][0] = i;
sparseArr[count][1] = j;
sparseArr[count][2] = arr1[i][j];
count++;
}
}
}
//打印稀疏数组
System.out.println("遍历稀疏数组");
for (int i = 0; i < sparseArr.length; i++) {
for (int j = 0; j < sparseArr[0].length; j++) {
System.out.print(sparseArr[i][j] + " ");
}
System.out.println();
}
//稀疏数组------>二维数组
//先得到二位数组的行列数
int row = sparseArr[0][0];
int col = sparseArr[0][1];
int[][] arr2 = new int[row][col];
//遍历稀疏数组，同时给二维数组赋值
for (int i = 1; i < sparseArr.length; i++) {
row = sparseArr[i][0];
col = sparseArr[i][1];
//该位置上对应的值
int val = sparseArr[i][2];
arr2[row][col] = val;
}
//打印二维数组
System.out.println("遍历还原后的二维数组");
for (int i = 0; i < arr2.length; i++) {
for (int j = 0; j < arr2[0].length; j++) {
System.out.print(arr2[i][j] + " ");
}
System.out.println();
}
}
}
输出：
打印二维数组
0 0 0 22 0 0 15
0 11 0 0 0 17 0
0 0 0 -6 0 0 0
0 0 0 0 0 39 0
91 0 0 0 0 0 0
0 0 28 0 0 0 0
遍历稀疏数组
6 7 8
0 3 22
0 6 15
1 1 11
1 5 17
2 3 -6
3 5 39
4 0 91
5 2 28
遍历还原后的二维数组
0 0 0 22 0 0 15
0 11 0 0 0 17 0
0 0 0 -6 0 0 0
0 0 0 0 0 39 0
91 0 0 0 0 0 0
0 0 28 0 0 0 0
