day06作业

一.方法

1.方法是完成特定功能的代码块。

修饰符  返回值类型  方法类型（参数类型  参数名1，参数类型  参数名2,...）{

方法体语句；

return返回值；

}

修饰符：目前就用public static。

返回值类型：就是功能结果的数据类型。

方法名：符合命名规则即可。方便调用。

参数：

*形式参数：就是方法定义的，用于接收实际参数的。

*实际参数：就是实际参与运算的。

参数类型：就是参数的数据类型

参数名：就是变量名

方法体语句：就是完成功能的代码

return：结束方法的

返回值：就是功能的结果，由return带给调用者；返回值是什么类型，返回值类型就是该类型

2.有具体返回值

a.单独调用，一般来说没有意义，不推荐。

b.输出调用，但是不够好。因为我们可能需要针对结果进行进一步的操作。

c.赋值调用，推荐方案。

无具体返回值类型

a.单独调用

b.输出调用（错误）

c.赋值调用（错误）

3.

import java.util.Scanner;
class FunctionSum {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入第一个数");
        int a = sc.nextInt();
        System.out.println("请输入第二个数");
        int b = sc.nextInt();
        int s = add(a,b);
        System.out.println(s);
    }
    public static int add(int a, int b){
        return a + b;
    }
}

import java.util.Scanner;
class FunctionCompare {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入第一个数：");
        int x = sc.nextInt();
        System.out.println("请输入第二个数：");
        int y = sc.nextInt();
        boolean b = isEquals(x,y);
        System.out.println(b);
    }
    public static boolean isEquals(int a, int b){
        return a == b;
    }
}

import java.util.Scanner;

class Test1_Method {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入第一个整数：");
        int x = sc.nextInt();
        System.out.println("请输入第二个整数：");
        int y = sc.nextInt();
        int m = getMax(x,y);
        System.out.println("max = " + m);
        boolean b = isEquals(x,y);
        System.out.println(b);
    }
    public static int getMax(int a,int b){
        return(a > b)? a : b;
    }
}

import java.util.Scanner;

class Test2_Method {
    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        System.out.println("请输入行数：");
        int m = sc.nextInt();
        System.out.println("请输入列数：");
        int n = sc.nextInt();
        printRectangle(m,n);

    }
    public static void printRectangle(int a,int b){

        for (int i = 1;i <= a ;i++ ) {
            for (int j = 1;j <= b ;j++ ) {
                System.out.print("* ");
            }
            System.out.println();
        }
        return;
    }

}

import java.util.Scanner;

class FunctionMultiplication {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入n：");
        int n = sc.nextInt();
        multiplication(n);

    }

    public static void multiplication(int n){
        for (int i = 1;i <= n ;i++ ) {
            for (int j = 1;j <= i ;j++ ) {
                System.out.print(j + "*" + i + "=" +i*j + "	");
            }
            System.out.println();
        }
    }
}

4.在同一个类中，方法名相同，参数列表不同。与返回值类型无关。

import java.util.Scanner;

class Test_Overload {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入第一个整数：");
        int x = sc.nextInt();
        System.out.println("请输入第二个整数：");
        int y = sc.nextInt();
        boolean b1 = isEquals(x,y);
        System.out.println(b1);
        System.out.println("请输入第一个小数：");
        double m = sc.nextDouble();
        System.out.println("请输入第二个小数：");
        double n = sc.nextDouble();
        boolean b2 = isEquals(m,n);
        System.out.println(b2);
    }
    public static boolean isEquals(int a,int b){
        return a == b;
    }
    public static boolean isEquals(double a,double b){
        return a == b;
    }
}

三.数组

1.数组是存储同一种数据类型多个元素的集合。也可以看成一个容器。

数组既可以存储基本数据类型，也可以存储引用数据类型。

2.数据类型[] 数组名 = new 数据类型[数组的长度]；

数据类型[] 数组名 = {元素1，元素2，...}

3.ArrayIndexOutOfBoundsException：数组索引越界异常

NullPointerException：空指针异常

4.

class Test4_Array {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
        print(arr);
    }
    public static void print(int[] arr){
        for (int i = 0;i <= arr.length ;i++ ) {
            System.out.print(arr[i] + " ");
        }
    }
}

class Test5_Array {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
        int m1 = getMax(arr);
        System.out.println(m1);
        int m2 = getMin(arr);
        System.out.println(m2);
    }
    public static int getMax(int[] arr){
        int max = arr[0];
        for (int i = 1;i < arr.length ;i++ ) {
            if (arr[i] > max) {
                max = arr[i];
            }
        }
        return max;
    }
    public static int getMin(int[] arr){
        int min = arr[0];
        for (int i = 1;i < arr.length ;i++ ) {
            if (arr[i] < min) {
                min = arr[i];
            }
        }
        return min;
    }
}

class Test6_Array {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
        reverseArray(arr);
        print(arr);
    }
    public static void reverseArray(int[] arr){
        for (int i = 0;i < arr.length/2 ;i++ ) {
            int temp = arr[i];
            arr[i] = arr[arr.length-1-i];
            arr[arr.length-1-i] = temp;
        }
    }
    public static void print(int[] arr){
        for (int i = 0 ;i < arr.length ;i++ ) {
            System.out.print(arr[i] + " ");
        }
    }
}

import java.util.Scanner;

class Test7_Array {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个1~7之间的整数：");
        int i = sc.nextInt();
        char week = getWeek(i);
        System.out.println("星期" + week);
        
    }
    public static char getWeek(int m){
        char[] arr = {' ','一','二','三','四','五','六','日'};
        return arr[m];
    }
}

class Test2_Array {
    public static void main(String[] args) {
        int[] arr = {11,22,33,44,55};
        int index = getIndex(arr,11);
        System.out.println(index);
    }
    public static int getIndex(int[] arr,int value){
        for (int i = 0;i < arr.length ;i++ ) {
            if (arr[i] == value) {
                return i;
            }
        }
        return -1;
    }
}

class Test8_Array {
    public static void main(String[] args) {
        int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};
        print(arr);
    }
    public static void print(int[] arr){
        for (int i = 0;i < arr.length ;i++ ) {
            for (int j = 0;j < arr[i].length ;j++ ) {
                System.out.print(arr[i][j] + " ");
            }
            System.out.println();
        }
    }
}

class Test9_Array {
    public static void main(String[] args) {
        int[][] arr = {{22,66,44},{77,33,88},{25,45,65},{11,66,99}};
        int sum = 0;
        for (int i = 0;i < arr.length ;i++ ) {
            for (int j = 0;j < arr[i].length ;j++ ) {
                sum = sum + arr[i][j];
            }
        }
        System.out.println(sum);
    }
}

7.基本数据类型的值传递，不改变原值，因为方法调用后就会弹栈，而局部变量随之消失

引用数据类型的值传递，改变原值，因为即使方法调用后弹栈，但是堆内存中的数组对象还在，可以通过地址继续访问。