正确的打开“方法”！

二维数组

1.二维数组的元素是多个一维数组

// 二維數組的定義和使用
        // 3称为二维数组arr的二维长度
        // 4称为二维数组arr的一维长度
        int[][] arr = new int[3][4];
        // 第一个一维数组的初始化 arr[0]
        arr[0][0] = 1;
        arr[0][1] = 2;
        arr[0][2] = 3;
        arr[0][3] = 4;
        // 第二个一维数组的初始化 arr[1]
        arr[1][0] = 5;
        arr[1][1] = 6;
        arr[1][2] = 7;
        arr[1][3] = 8;
        // 第三个一维数组的初始化 arr[2]
        arr[2][0] = 9;
        arr[2][1] = 10;
        arr[2][2] = 11;
        arr[2][3] = 12;

2.二维数组的动态初始化

int[][] arr = new int[3][4];
int n = 1;
for(int i=0;i<3;i++){
    for(int j=0;j<4;j++){
        arr[i][j] = n++;
        System.out.println(arr[i][j]);
    }
}

3.二维数组的静态初始化

int[][] arr = {
    {89,88,92,76,100,89,78},
    {89,83,78,98,87,79,89,78,99,88},
    {99,96,88,87,80,100,99,97,78,92,91,88}
};

4.如何动态创建不规则的二维数组

// 指定二维数组的长度，不指定一维数组的长度
int[][] arr = new int[3][];
// 指定一维数组的长度
arr[0] = new int[5];
arr[1] = new int[10];
arr[2] = new int[8];
//一共存了多少数据：5+10+8
// 指定元素为1-23
int n=1;
for (int i = 0; i < arr.length; i++) {
    for (int j = 0; j < arr[i].length; j++) {
        arr[i][j] = n++;
    }
}

5.通过Arrays.toString 输出二维数组中的每个元素

int[][] arr = {
    {89,88,92,76,100,89,78},
    {89,83,78,100,87,79,89},
    {99,96,88,87,80,100,99}
};
// Arrays.toString 中需要传入的是一维数组
for(int i=0;i<arr.length;i++){
    System.out.println(Arrays.toString(arr[i]));
}

---

方法的定义和使用

1.方法的构成
* 修饰符 : public protected private static final abstract
* 返回值 : void(空) int(基本数据类型) String(引用数据类型)
* 方法名 : 方法的名字
* 方法体 : 方法的执行语句（功能实现）

2.方法的定义和调用

public static void main(String[] args) {
    System.out.println("main开始");
    m1();// 方法的调用
    System.out.println("main结束");
}
/**
 * 方法的定义
 */
public static void m1() {
    System.out.println("m1开始");
    m2();// 方法的调用
    System.out.println("m1结束");
}
public static void m2(){
    System.out.println("m2开始");
    System.out.println("m2结束");
}

3.方法定义和使用时，参数的使用
* 形式参数：方法定义的时候指定的参数
* 实际参数：方法调用的时候，指定的参数

public static void main(String[] args) {
    m("林志玲"/*实参*/);
}
public static void m(String name/*形参*/){
    System.out.println("明年暑假带" +name+ "去哈尔滨避暑");
}

4.方法的返回值和返回值类型
* 使用 return 关键字返回数据
* 方法的返回值和返回值类型要一致

public static void main(String[] args) {
    int n = add(2,3);// 返回值为 int 型
    System.out.println(n);
}
public static int/*返回值类型*/ add(int a,int b){
    return a+b;// 返回值
}

5.使用方法封装语句，使代码更简洁
* main 方法中书写的语句：
* 1.接收用户输入
* 2.调用业务逻辑处理方法
* 3.打印结果
* 其余语句均放在各方法体内

6.return的使用
* 如果方法的返回值是void，则不需要return语句，但是，也可以写上return。对于void方法，return一般用来处理需要结束方法的情况，用法就和for或Switch中的break类似

public static void register() {
    String name = "";
    if(name.equals("") || name==null){
        return ;//结束程序，不执行正常注册语句
    }
    // 正常的注册..
    .......
}

7.static的使用
* 静态的 类的
* 在静态方法（static修饰的方法）中，只能调用静态方法和静态的全局变量
* 在一般方法中（没有static修饰的方法）中，可以调用一般方法和一般全局变量，也可以掉用静态方法和静态的全局变量
* 对于static修饰的方法来说，如果是类内部使用，直接使用类名就可以，如果是在其他类中使用，则需要通过类名.方法名的形式来调用
* 通过类名来调用的方法：
* Math.pow();
* Arrays.sort();
* System.arraycopy();

8.权限修饰符
* 权限修饰符，决定着方法的适用范围
* 各修饰符权限：
* public:同类中、同包下的不同类中、不同包中的类中都可以访问。
* default:默认修饰符（不写），受包的限制。同类中、同包下的不同类中、不同包中的类中不可以。
* private：私有的，受类的限制。同一个类中可见，其他都不可见。
* protected：受保护的

9.方法的重载和可变长参数
1. 重载（overload）：方法名相同、方法参数不同
* 参数个数不同
* 参数类型不同
* 顺序不同
2. 可变长参数：
* 一个方法里面只能有一个可变长参数，并且只能作为最后一个参数。
* 可变长参数相当于数组，不能和数组同时存在，和其他方法也构成重载关系。
3. >定义重载的add方法，完成两个int的相加，int和String的相加,String和int的相加，int和double类型的相加，三个int的相加

public static int add(int... a) {// 可变长参数
    int sum=0;
    for(int i=0;i<a.length;i++){
        sum+=a[i];
    }
    return sum;
}
public static int add(int a,int b) {
    return a+b;
}
public static String add(int a,String b) {
    return a+b;
}
public static String add(String a,int b) {
    return a+b;
}
public static double add(int a,double b) {
    return a+b;
}
public static int add(int a,int b,int c) {
    return a+b+c;
}

7.应用-打印圣诞树

编程，完成以下功能：
1、打印2棵圣诞树
2、打印10遍Hello
3、打印3棵圣诞树
4、打印5遍W

/**
 * 打印圣诞树，接收参数决定打印几棵树
 */
public static void printTree(int count) {
    for (int n = 4; n < 7; n += 2) {// 打印几个三角树叶
        for (int m = 0; m < n; m++) {// 一个三角树叶
            for (int q = 0; q < count; q++) {// 一行打印几棵
                for (int j = 0; j < (n - 1 - m) + (6 - n); j++) {// 前空格
                    System.out.print(" ");
                }
                for (int k = 0; k < 2 * m + 1; k++) {// 一行*数
                    System.out.print("*");
                }
                for (int j = 0; j < (n - 1 - m) + (6 - n); j++) {// 前空格 
                    System.out.print(" ");
                }
            }
            System.out.println();
        }
    }
    for (int i = 0; i < 4; i++) {// 树干
        for (int m = 0; m < count; m++) {
            for (int k = 0; k < 4; k++) {
                System.out.print(" ");
            }
            for (int j = 0; j < 3; j++) {
                System.out.print("*");
            }
            for (int k = 0; k < 4; k++) {
                System.out.print(" ");
            }
        }
        System.out.println();
    }
}
/**
 * 打印语句，接收参数决定打印语句内容和次数
 */
public static void printStr(String str,int num){
    for(int i=0;i<num;i++){
        System.out.print(i+1 +"、"+str + " ");
    }
    System.out.println();
}
/**
 * 实现题目需求的方法，调用打印语句和打印圣诞树方法
 */
public static void printTreeAndString(){
    printTree(2);
    printStr("Hello",10);
    printTree(3);
    printStr("World",5);
}
/**
 * 主方法，程序的入口
 */
public static void main(String[] args) {
    // 1.接收用户输入
    // 2.调用业务逻辑处理方法
    // 3.打印结果
    printTreeAndString();
}