Java基础03(数组，方法)

数组

静态初始化，给数组中每个元素赋值，由系统决定数组大小，例如：int [] arr = new int [1,2,3,4,5,6];
动态初始化，给出数组大小，由系统给每个数组元素一个初始值，例如：int [] arr = new int [3];

索引越界(ArrayIndexOutOfBoundsException)：访问了数组中不存在的索引对应的元素

   //索引越界 
        int [] arr = new int [3];
        System.out.println(arr[3]);

空指针(NullPointerException)：访问的数组已经不指向堆内存中的数据，造成空指针异常

    //空指针
        int [] arr1 = new int [3];
        arr1 = null;
        System.out.println(arr1[2]);
        System.out.println(arr1);//打印结果为null

null：空值，引用数据类型的默认值，表示不再指向任何有效的对象

数组常见操作

遍历

 public static void main(String[] args) {
        int [] arr = new int[]{1,2,3,4,5,6};
        //遍历输出数组元素
        for(int i = 0;i<arr.length;i++){
            System.out.println(arr[i]);
        }
    }

获取最值（冒泡排序）

package com.array;

public class arrayTravelse {
    public static void main(String[] args) {
        int [] arr = new int[]{88,82,76,74,55,8};
        //最值
        int max;
        int min;
        //比较趟数
        for (int j = 0;j<arr.length-1;j++){
            //每趟比较的次数
            for(int i =0 ;i<j;i++){
                if (arr[i]>arr[i+1]){
                    int t = arr[i+1];
                    arr[i+1] = arr[i];
                    arr[i] = t;
                }
            }
        }
        //新建数组接受排序后的数据
        int [] arr2 = arr;
        max = arr[arr.length-1];
        min = arr[0];
        System.out.println("排序后的数组为:");
        for (int h =0;h<arr2.length;h++){
            System.out.print(arr2[h]+"\t");
        }
        System.out.println();
        System.out.println("数组最大值为:"+max);
        System.out.println("数组最小值为:"+min);

    }
}

方法

方法是具有功能的代码块组织成为一个整体，使其具有特殊功能的代码集
注意：
方法必须先创建才能使用，该过程称为方法定义
方法创建后并不自动执行，而是手动调用后才执行，该过程称为方法调用
方法定义格式:

修饰符 返回类型 方法名([参数列表]){
	方法体;
	return 语句;
}

注意： return语句返回的数据类型要和方法定义时的数据类型一致,且return语句在方法体之后，否则报错Unreachable statement
方法调用格式:

方法名();

带参数的方法的使用

package com.method;
/*带参数方法的调用*/
import java.util.Scanner;
public class methodWithParam {
    public static void main(String[] args) {
        //变量参数的使用
        System.out.println("请输入一个整数");
        Scanner sc = new Scanner(System.in);
        int inputNumber = sc.nextInt();
        isEvenNumber(inputNumber);
        //常量参数的使用
        isEvenNumber(10);

    }
    //定义方法
    public static void isEvenNumber(int number){
        if (number%2 == 0){
            System.out.println(number+"是一个偶数");
        }else {
            System.out.println(number+"是一个奇数");
        }
    }
}

形参：方法定义中的参数，等同于变量定义格式

 public static void isEvenNumber(int Number)//int Number就是形参

实参：方法调用时的参数，等同于使用变量或常量

 isEvenNumber(10);
 isEvenNumber(inputNumber);//inputNumber，10都是实参

带返回类型的方法的使用:

package com.method;
/*带参数方法的调用*/
import java.util.Scanner;
public class methodWithParam {
    public static void main(String[] args) {
        //变量参数的使用
        System.out.println("请输入一个整数");
        Scanner sc = new Scanner(System.in);
        int inputNumber = sc.nextInt();
        Boolean j1 = isEvenNumber(inputNumber);
        System.out.println(j1);
        //常量参数的使用
        Boolean j2 = isEvenNumber(10);
        System.out.println(j2);
    }
    //定义方法判断奇偶数
    public  static Boolean isEvenNumber(int Number){
        if (Number%2 == 0){
            return true;
        }else {
            return false;
        }
    }
}

package com.method;
/*带参数方法的调用*/
import java.util.Scanner;
public class methodWithParam {
    public static void main(String[] args) {
        System.out.println("请输入要比较的两个整数,以空格隔开，以回车键结束输入");
        //从键盘获取要比较的值
        Scanner sc = new Scanner(System.in);
        int num1 = sc.nextInt();
        int num2 = sc.nextInt();
        //输出比较结果
        int result = getMax(num1,num2);// 等价于System.out.println(getMax(num1,num2));
        System.out.println(result);
    }
    //定义方法比较大小
    public static int getMax(int a,int b){
        if (a>b){
            return a;
        }else if(a==b){
            return a;
        }else {
            return b;
        }
    }
}

方法注意事项

• 定义的每个方法是平级关系，不能嵌套定义
• void表示无返回值，可以省略return，也可以单独书写return但是后面不加数据

方法的嵌套和递归：
方法的嵌套是指在一个方法中调用另一个方法的嵌套调用，方法的递归是指允许方法调用自身的过程

package com.method;

import java.util.Scanner;

/*方法的嵌套,计算a+b*c的值;
方法的递归，计算阶乘*/
public class methodOfRecursionAndNesting {
    public static void main(String[] args) {
        //获取要计算的三个数
        System.out.println("请输入三个整数，空格隔开，以回车键结束");
        Scanner sc = new Scanner(System.in);
        int numa = sc.nextInt();
        int numb = sc.nextInt();
        int numc = sc.nextInt();
        //保存计算结果
        int Result = sum(numa,numb,numc);
        System.out.println(numa+"+"+numb+"*"+numc+"="+Result);
        System.out.println("请输入要计算阶乘的整数");
        //获取要计算阶乘的整数
        Scanner sc1 = new Scanner(System.in);
        int numd = sc1.nextInt();
        int Fatorial = fatorial(numd);
        System.out.println(numd+"的阶乘等于"+Fatorial);
    }
    //获取乘积
    public static int mul(int b,int c){
        int prod= b * c;
        return prod;
    }
    //表达式计算方法
    public static int sum (int a,int b ,int c){
        //利用方法的嵌套获取b,c的乘积
        int sumResult = a+mul(b,c);
        return sumResult;
    }
    //利用方法的递归计算阶乘
    public static int fatorial(int d){
        if (d == 0 |d == 1){
            return 1;
        }else {
            int fat = d * fatorial(d-1);
            return fat;
        }
    }
}