05.函数和数组

Posted 2021-05-16 W-forever

函数

函数定义的格式：
    修饰符 返回值的类型 函数名（形参列表）{
    	需要封装的功能代码；
	}
修饰符：public static
返回值类型：函数执行完毕后，返回的结果的数据类型
函数名：函数名（），要符合变量名的命名规范
注意：有些函数是没有结果返回给调用者的，那么这个时候的返回值的类型是void

class demn{
    public static void main(String[] args){
        int num = add(2, 3);
        System.out.println("结果：" + sum);
    }
    //做加法功能的函数
    public static int add(int a, int b){
            int a = 2;
            int b = 3;
            return a + b;
        }
    public static void add(int a, int b){
        int sum = a + b;
        System.out.println(sum);
    }
    public static int max(int a, int b){
        int max = 0;
        if(a > b){
            max = a;
        }else{
            max = b;
        }
        return max;
    }
    //定义一个函数返回分数的等级
    public static String getgrade(int score){
        String grade = "";
        if(score >= 90 && score <= 100){
            grade = "A";
        }else if(score >= 80 && score <= 90){
            grade = "B";
        }else{
            grade = "C";
        }
        return grade;
    }
}

return关键字，函数的重载

class demn{
    public static void main(String[] args){
        
    }
    public static void add(int a, int b){
        System.out.println("总和" + (a + b));
        return;
    }
}
return关键字的作用：
    1.返回数据给函数的调用者
    2.函数一旦执行到return关键字，那么该函数结束
    3.一个函数是void类型，那么也可以出现return关键字，但是return关键字后面不可以有任何数

函数的重载：在一个类中出现了两个或两个以上的同名函数，这个称为函数的重载
函数重载的作用：同一个函数名可以出现不同的函数，以应对不同个数或者不同数据类型的参数
函数重载的要求：
    1.函数名一致
    2.形参列表不一致（形式参数或者对应的数据类型不一致）

public static void add(int a, int b){
    System.out.println("两个参数的总和" + (a + b));
}
public static void add(int a, int b, int c){
    System.out.println("两个参数的总和" + (a + b + c));
}
public static void add(int a, int b, int c, int d){
    System.out.println("两个参数的总和" + (a + b + c + d));
}

数组

数组是同一种数据类型的容器

数组的定义格式：

​ 数据类型[] 变量名 = new 数据类型[长度];

class demn{
    int a = 10;
    public static void main(String[] args){
        //定义一个数组
        int[] arr = new int[50];
        arr[0] = 20;
        arr[1] = 30;
        arr[2] = 40;
        arr[4] = 50;
        System.out.println("hello world");
        //等号将数组对象的内存地址赋予给arr变量
        //查看数组中的所有数据
        for(int index = 0; index < arr.length; index ++){
            System.out.println(arr[index]);
        }
    }
}

• 栈内存的特点：

  栈内存存放的都是局部变量，变量一旦出了自己的作用域，那么马上会重内存中消失，释放内存空间

• 堆内存的特点：

  堆内存存储的都是对象数据（除了八中基本数据类型之外的数据），对象一旦被使用完，并不会马上从内存中消失，而是等待垃圾回收器，不定时把垃圾回收，这时候该对象消失，释放资源（凡是以new关键字创建的对象，jvm都会在堆内存中开辟一个新的空间，创建一个新的对象）

• 局部变量：

  如果一个变量是在方法（函数）内部声明的，那么该变量就是一个局部变量

• 成员变量：

  成员变量就是定义在方法之外，类之内的

数组常见问题，数组的初始化方式

class demn{
    public static void main(){
        //动态初始化
        int[] arr = new int[2];
        arr = null;//让该变量不要引用任何的对象，不要记录任何的内存地址
        arr[1] = 10;
        System.out.println(arr[1]);//报错，NullPointerException
    }
}

数组中最常见的问题：
    1.NullPointerException，空指针异常
    	原因：引用类型变量没有指向任何对象，而访问了对象的属性或者是调用了对象的方法
    2.索引值越界

数组初始化的方式：
    动态初始化：
    	数据类型 变量名 = new 数据类型[长度];
    静态初始化：
    	数据类型[] 变量名 = {元素1， 元素2， ……}；

找一个数组中的最大值
class demn{
    public static void main(String[] args){
        int[] arr = new int[50];
        int max = getmax(arr);
        System.out.println(max);
    }
    public static int getmax(int[] arr)
    {
        int max = arr[0];
        for(int i = 1; i < getmax.length; i++){
            if(arr[i] > max){
                max = arr[i];
            }
        }
        return max;
    }
}

排序算法
选择排序
public static void selectsort(int[] arr){
    for(int j = 0; j < 4; j++){
        for(int i = j; i < 4; i++){
            if(arr[j] > arr[i]){
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
    }
}
冒泡排序
public static void selectsort(int[] arr){
    for(int i = 0; i < 3; i++){
        for(int j = 0; j < 3 - i; j ++){
            if(arr[j] > arr[j + 1]){
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}
二分查找法
class demn{
    public static void main(String[] args){
        int[] arr = {12, 15, 19, 24, 53};//有序的数组才可以进行二分法查找
        searchelement(arr, 34);
        
    }
    public static void searchelement(int[] arr, int target){
        for(int i = 0; i < arr.length; i++){
            if(arr[i] == target){
                return i;
            }
        }
        return -1;
    }
    public static void selectelement(int[] arr, int target){
        int max = arr.length - 1;
        int min = 0;
        int mid = (max + min) / 2;
        while(true){
            if(target > arr[mid]){
                min = mid + 1;
            }else if(target < arr[mid]){
                max = mid - 1;
            }else{
                return mid;
            }
            mid = (min + max) / 2;
            if(max < min){
                return -1;
            }
        }
    }
}

arrays数组工具的使用

数组工具类
import java.util.*;
class helloworld{
    public static void main(String[] args){
        int[] arr = {12, 3, 45, 5 ,23};
        Arrays.sort(arr);
        String info = Arrays.toString(arr);
        System.out.println(info);
        
        int index = Arrays.binarySearch(arr, 10);//如果能找到就返回该书的下标值，如果不能找到，就返回一个负数表示（
        System.out.println(index);
    }
}

二维数组

二维数组的定义格式：
    数据类型[][] 变量名 = new 数据类型[长度1][长度1];  
二维数组的初始化方法：
    动态初始化：
    	数据类型[][] 变量名 = new 数据类型[长度1][长度1]; 
    静态初始化：
        数据类型[][] 变量名 = {{元素1，元素2}， {……}， {……}};
数组的特点：
    1.数组是智能存储同一种数据类型的数据
    2.数组是会给存储到数组的元素分配一个索引值，索引值从零开始，最大的索引知识length-1
    3.数组一旦初始化，长度固定
    4.数组和数组之间的元素和元素之间的内存地址是连续

class demn{
    public static void main(String[] args){
        int[][] arr = new int[3][4];
        arr[1][1] = 100;
        System.out.println("二维数组的长度" + arr.length);//3
        System.put.println(arr[1].length);
        
        int[][] arr = {{1, 2, 4, 5}, {34, 55}, {354, 453}};
        System.out.println(arr[2].length);
        System.out.println(arr[1].length);
        
        for(int i = 0; i < arr.length; i ++)
        {
            System.out.println(arr[i]);//输出的是三个内存地址
        }
        
        for(int i = 0; i < arr.length; i++){
            for(int j = 0; j < arr[i].length; j ++){
                System.out.println(arr[i][j]);
            }
            System.out.println();
        }
    }
}