Java 学习笔记 Day007

今天主要是二维数组的熟悉 和 Java的方法

二维数组（多维数组）
二维 通俗的解释就是 一维数组的数组，三维数组 是二维数组的数组，依次类推。
定义二维数组的语法为

int[][] arrayname = new int[n][m];// 数据类型，名称和矩阵的大小可变

下面给一段代码熟悉一下：

//file name : arrayTest21.java
import java.util.Arrays;
public class arrayTest21 {

    public static void main(String[] args) {
        //生成二维矩阵
        int[][] mGroup = new int[5][5];
        for (int i = 0; i < mGroup.length; i++) {
            for (int j = 0; j < mGroup[i].length; j++) {
                mGroup[i][j] = (int)(Math.random() * 100);
            }
        }
        System.out.println("生成的二维矩阵为：");
        for (int i = 0; i < mGroup.length; i++) {
            System.out.println(Arrays.toString(mGroup[i]));
        }
        //求二维矩阵所有数据的和
        int sum = 0 ;
        for (int i = 0; i < mGroup.length; i++) {
            for (int j = 0; j < mGroup[i].length; j++) {
                sum += mGroup[i][j];
            }
        }
        System.out.println("二维矩阵所有数据的和为：" + sum);
        //每一行的最大和最小值
        System.out.println("\n每一行的最大和最小值");
        for (int i = 0; i < mGroup.length; i++) {
            int tempMax = 0;
            int tempMin = 0;
            for (int j = 0; j < mGroup[i].length; j++) {
                if(j == 0){
                    tempMax = mGroup[i][j];
                    tempMin = mGroup[i][j];
                } else{
                    if(tempMax < mGroup[i][j]) {
                        tempMax = mGroup[i][j];
                        }
                    if(tempMin > mGroup[i][j]) {
                        tempMin = mGroup[i][j];
                    }
                }
            }
            System.out.println("第" + (i + 1) + "行：max = " + tempMax + ",min = " + tempMin );
        }
        //每一列的最大和最小值
        System.out.println("\n每一列的最大和最小值");
        for (int i = 0; i < mGroup.length; i++) {
            int tempMax = 0;
            int tempMin = 0;
            for (int j = 0; j < mGroup[i].length; j++) {
                if(j == 0){
                    tempMax = mGroup[j][i];
                    tempMin = mGroup[j][i];
                } else{
                    if(tempMax < mGroup[j][i]) {
                        tempMax = mGroup[j][i];
                        }
                    if(tempMin > mGroup[j][i]) {
                        tempMin = mGroup[j][i];
                    }
                }
            }
            System.out.println("第" + (i + 1) + "列：max = " + tempMax + ",min = " + tempMin );
        }
    }

}

方法：Java方法是语句的集合，它们在一起执行一个功能
方法的定义语法：
*修饰符 返回值类型 方法名(参数类型 参数名){
…
方法体
…
return 返回值;
}*
修饰符：这是可选的定义了该方法的访问类型，限制方法的使用范围和使用方式。（public static）
返回值类型 ：声明方法返回值类型。returnValueType 是方法返回值的数据类型。有些方法执行所需的操作，但没有返回值，在这种情况下，returnValueType 是关键字void。
方法名：是方法的实际名称。方法名和参数表共同构成方法签名，用来调用方法。
参数类型：参数像是一个占位符。当方法被调用时，传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的，方法可以不包含任何参数。
方法体：方法体包含具体的语句，方法的实现。
return：是一个特殊的语句，结束方法的运行，给调用者返回执行方法后的结果
注意：调用方法时，方法名和参数表必须严格符合定义。
如果是没有返回值（void）的方法可以写return语句，但是不可以带返回值。

方法中的参数是数组时，方法中可以修改数组的数据，但如果参数是普通的数据类型，方法中不可修改原来的数据类型。（因为数组名称是一个引用变量）例子如下：

//file name : funcTest02.java
import java.util.Arrays;

public class funcTest02 {

    public static void main(String[] args) {
        int a = 12;
        int[] b = {12, 13, 14, 15};
        //调用 test01 和test02 方法
        test01(a);
        test02(b);
        //打印输出变量a，a 并没有改变
        System.out.println(a);
        //打印输出数组b，b 已经被改变。  
        System.out.println(Arrays.toString(b));
        //原因是数组存放在内存中， 而b是一个声明数组在内存中位置的一个变量，这个变量存在于 栈 中
        //所以方法中修改了数组， 其实真正的修改了数组在内存中的值。而普通的变量在方法中使用的只是变量的一个副本。
    }
    public static void test01(int a){
         a = 13;
    }
    public static void test02(int[] d){
        d[d.length - 1] = 1000;
    }

}
//结果为
//12
//[12, 13, 14, 1000]

方法的重载overload：同一个类中，存在方法名相同的，参数表不相同的，返回值无关的方法。这些方法互相成为重载方法。

public static int func01(int a){}
public static int func01(int a, double b){}
public static int fumc01(int a, int b){}
//一个类中有无限多个同名的方法，但是同名的方法参数表不相同
//例如再定义一个方法 public static int func01(int b){}  将会报错。

可变参数：参数不确定的方法定义可以用可变参数来实现(可变参数可以是0个，或多个)

public static int add(int ...  a)   // 其实 a 就是一个数组。
public static int fun1( int a , int b, int ... c)   //定参和变参 可以混合使用，  可变参数必须放在所有定参 的后面，而且一个方法只能有一个变参。

代码在于多写多练，下面是一个方法的练习：

/*3、想办法计算  s= (1！) + (1！ + 2！) + (1！ + 2！ + 3！) + ... + (1！ + 2！ + 3！ + ... + n!)     ， n小于10
*/
//file name : Homework02.java
import java.util.Scanner;
public class Homework02 {
    public static void main(String[] args) {
        Scanner s  = new Scanner(System.in);
        System.out.print("请输入一个整数：");
        int number = s.nextInt();
        if(number > 0){
            double resultOfSum = allSum(number);
            System.out.println("结果为：" + resultOfSum);
            }else {
                System.out.println("结果为： 0");               
            }
    }
    //求阶乘
    public static double funcFactorial(int  num01){
        double perProduct = 1;
        for (int i = 1; i <= num01; i++) {
            perProduct *= i;
        }
        return perProduct;
    }
    //求括号内的和
    public static double sumInside(int num02){
        double perSum = 0;
        for (int i = 1; i <= num02; i++) {
            perSum += funcFactorial(i);
        }
        return perSum;
    }
    //求总的和
    public static double allSum(int num03){
        double SumOfAll = 0;
        for (int i = 1; i <= num03; i++) {
            SumOfAll += sumInside(i);
        }
        return SumOfAll;
    }
}