Java方法及数组

Java方法

概述

• 方法是解决一类问题的步骤有序组合
• 方法包含于类或者对象
• 方法在程序中被创建，在其他地方被引用
• 方法的设计原则就是方法只能完成一个功能，利于后期的扩展

方法的组成

方法包含一个方法头和一个方法体

• 修饰符：修饰符是可选的，告诉编译器如何调用该方法
• 返回值类型：方法可能会返回值，returnValueType是方法返回值的类型，有些方法执行所需的操作，但没有返回值的情况下returnValueType关键字为void
• 方法名：是方法的实际名称
• 参数类型：参数像是一个占位符，当方法被调用时，传递值给参数，这个值被称为实参或变量，参数列表是指方法的参数类型，顺序和参数的个数，番薯是可选的，方法可不包含参数
  1. 形式参数：在方法被调用食欲接收外界输入的数据
  2. 实参：调用方法时实际传给方法的数据
• 方法体：方法体包含具体的语句，定义该方法的功能

package com.zedhz.method;

public class Demo02 {
    public static void main(String[] args) {
        int max = max(123,53);
        System.out.println(max);

    }

    //比大小
    public static int max(int num1,int num2){

        int result = 0;

        if (num1==num2){
            System.out.println("num1==num2");
            return 0; //终止方法
        }

        if (num1>num2){
            result = num1;
        }else {
            result = num2;
        }

        return result;
    }
}

方法的重载

• 方法名称必须相同
• 参数列表必须不通（个数不同，或类型不同，参数排列顺序不同）
• 方法的返回类型可以相同也可以不相同
• 仅仅返回类型不同不足以构成方法重载
• 方法名称相同时，编译器会根据调用方法的参数个数，参数类型等去逐个匹配，以选择对应的方法，如果匹配失败，则编译器会报错

可变参数

• 在方法声明中，在指定参数类型后加一个省略号…
• 一个方法中只能指定一个可变参数，它必须是方法的最后一个参数，任何普通参数必须在它之前声明
• 可变参数定义类型只能是当前类型

package com.zedhz.method;

public class Demo03 {
    public static void main(String[] args) {
        Demo03 demo03 = new Demo03();
        demo03.test(2,2,3);
    }

    //它必须是方法的最后一个参数，任何普通参数必须在它之前声明
    public void  test(int x,int... i){

        //通过数组下标来取第几个值
        System.out.println(i[0]);
    }
}

递归

递归就是自己调用自己，它包含两个部分

1. 递归头：什么时候不调用自身方法，如果没有头将进入死循环
2. 递归体：什么时候需要调用自身方法

package com.zedhz.method;

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

        System.out.println(f(100));

    }
    //5!  5*4*3*2*1
    //4!  4*3*2*1
    //3!  3*2*1
    //2!  2*1
    //1!  1*1
    public static int f(int n){
        if (n==1){
            return 1;
        }else {
            return n*f(n-1);
        }
    }
}

数组

数组是想同类型数据的有序集合，其中每一个数据乘坐一个数组元素，每个元素可以通过下标来访问他们，数组的第一个下标为0

数组声明创建

• 必须声明数组变量，声明数组变量的语法如下：

• datatype[] arrayRefVar //首选方法
  dataType arrayRefVar[] //效果相同，但不是首选
  

• new操作符创建数组语法如下

• dataType[] arrayRefVar = new dataType[arraySize];
  
  int[] nums; //声明一个数组
  nums = new int[10]; //创建一个10个长度的数组
  

• 数组的元素通过索引来访问，默认是0下标

• arrays.length //获取数组长度
  

数组的初始化

1. 静态初始化

   • int[] a = {1,2,3};
     Man[] mans = {new Man(1,1),new Man()2,2};
     

2. 动态初始化

   • int[] a = new int[2];
     a[0] = 1;
     a[1] = 2;
     

3. 默认初始化

   • 数组是引用类型，它的元素相当于实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化

内存分析

• 堆：

  存放new的对象和数组

  可以被所有线程共享，不会存放别的对象引用

• 栈：

  存放基本变量类型（会包含这个基本类型的具体数值）

  引用对象的变量（会存放这个引用在堆里面的具体地址）

• 方法区:

  可以被所有的线程共享

  包含了所有的class和static变量

数组的使用

• 普通For循环
• For-Each循环
• 数组作方法入参
• 数组作返回值

package com.zedhz.array;

public class Demo04 {
    public static void main(String[] args) {
        int[] arrays = {1,2,3,4,5,6,7,8,9,10};

        //没有下标
//        for (int array : arrays) {
//            System.out.println(array);
//
//        }

        printArray(arrays);
        System.out.println("============================");
        int[] reverse = reverse(arrays);
        printArray(reverse);
        System.out.println("=============================");

        sumArrays(arrays);
    }

    //打印数组元素
    public static void printArray(int[] arrays){
        for (int i = 0; i < arrays.length; i++) {
            System.out.print(arrays[i] + "  ");
        }
    }


    //计算数组元素的总和
    public static void  sumArrays(int[] arrays){
            int sum = 0;
        for (int i = 0; i < arrays.length; i++) {
            sum+=arrays[i];
        }
        System.out.println(sum);
    }

    //反转数组
    public static int[] reverse(int[] arrays){
        int[] result = new int[arrays.length];

        for (int i = 0,j = arrays.length -1; i < arrays.length; i++,j--) {
            result[j] = arrays[i];
        }

        return result;
    }
}

多维数组

可以看作为数组的数组，及数组中嵌套数组

二维数组

• int a[][] = new int[2][5];
  

获取二维数组的值

package com.zedhz.method;

public class Demo07 {

    public static void main(String[] args) {
        /**
         * 1,2 arrays[0]
         * 2,3 arrays[1]
         * 3,4 arrays[2]
         * 4,5 arrays[3]
         */
        int[][] arrays = {{1,2},{2,3},{3,4},{4,5}};
        System.out.println(arrays[0][0]);
    }


}

Arrays类

• 数组的工具类java.util.Arrays
• 数组工具类可供我们对数据对象进行一些基本操作
• Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用，而不用使用对象来调用

Arrays类常用功能

• 给数组赋值：fill方法
• 对数组排序：sort方法，按升序
• 比较数组：equals方法比较数组元素值是否相等
• 查找数组元素：binarySearch方法能对排序好的数组进行二分查找法操作

冒泡排序

• 比较数组中两个相邻元素，如果第一个数比第二个数大，就交换他们的位置
• 每一次比较，都会产生出一个最大或者最小的数字
• 下一轮，则可以少一次循环
• 依次循环，直到结束

package com.zedhz.array;

import java.util.Arrays;

public class Demo07 {
    public static void main(String[] args) {
        int[] array = {5,7,0,1,2,6};

        int[] sort = sort(array);
        System.out.println(Arrays.toString(sort));

    }

    public static int[] sort(int[] array){

        int temp = 0;
        //外层判断循环要走多少次
        for (int i = 0; i < array.length-1; i++) {
            //内层循环，判断两个数值，如果第一个数大于第一个数，则交换位置
            for (int j = 0; j < array.length-i-1; j++) {
                if (array[j]>array[j+1]) {
                    temp = array[j+1];
                    array[j+1] = array[j];
                    array[j] = temp;
                }
            }
        }
        return array;
    }
}