【初识Java方法与Java数组】

Java方法

一、定义及调用

1、修饰符(public)

2、返回值(没有返回值，则关键字使用void)

3、方法名(add、test、……)驼峰规则

4、参数类型(实参+形参)

方法体：

修饰符 返回值类型 方法名(参数类型 参数名){undefined

……

方法体

……

return 返回值;

}

加法和比较大小

package com.liuht.www;
​
public class Demo2 {
    public static void main(String[] args) {
int sum=add(1,2);
        System.out.println(sum);
​
    }
    public static int add(int a,int b){
        return a+b;
    }
​
​
​
​
}

package com.liuht.www;
​
public class Demo3 {
    public static void main(String[] args) {
     int max =max(10,20);
        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;
        }

二.方法的重载

1.方法名称必须相同

2、参数列表必须不同(个数、类型、参数排列顺序)

3、方法的返回类型可以相同，可以不同

4、仅仅返回类型不同不足以成为方法的重载

package com.liuht.www;
​
public class Demo4 {
    public static void main(String[] args) {
        int sum = add(1,2,3);
        System.out.println(sum);
​
    }
​
    public static int add(int a, int b) {
        return a + b;
    }
​
    public static int add(int a, int b,int c) {
        return a + b+c;
    }
​
}

三.可变参数

1. 在JDK1.5开始，Java支持传递同类型的可变参数给一个方法

2. 再方法声明中，在指定参数类型后加上一个省略号（...）。

3. 一个方法只能指定一个可变参数，他必须是方法的最后一个参数。任何普通的参数必须在他之前声明。

四.递归

A方法调用B方法, 我们很容易理解! 递归就是: A方法调用A方法! 就是自己调用自己 利用递归可以用简单的程序来解决一些复杂的问题. 它通常把一个大型复杂的问题层层转化一个与原问题相似的规模较小的问题来求解, 递归策略只需少量的程序就可以描述出解题过程所需要的多次重复计算, 大大减少了程序的代码量. 递归的能力在于用有限的语句来定义对象大的无限集合. 递归结构包括两个部分: 递归头: 什么时候不调用自身方法. 如果没有头, 将陷入死循环. 递归体: 什么时候需要调用自身方法.

package com.liuht.www;
​
public class Demo5 {
    public static void main(String[] args) {
        System.out.println(f(5));
    }
    public static int  f(int n){
        if(n==1){return 1;}
        else{return n*f(n-1);
        }
    }
}

Java数组

一.数组概述

1.数组是相同类型数据的有序集合

2.数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成

3.其中，每一个数据称作一个数组元素，每个数组元素可以通过一个下标来访问它

二.数组声明创建

for(int i=0;i< arrays.length;i++) a.length可以测数组长度

int[] a={1,2,3,4,5,6}; 数组长度是确定的，数组一旦被创建，其长度不可改变。

package Arrays;
​
public class Dome1 {
    public static void main(String[] args) {
      int[] nums;
      nums=new int[2];
      nums[0]=1;
      nums[1]=2;
        System.out.println(nums[0]);
    }
}

三.数组使用

public static int[] reverse(int[] arrays) {反转数组
    int[] result = new int[arrays.length];
    for (int i = 0, j = result.length - 1; i < arrays.length; i++, j--) {
        result[j] = arrays[i];
    }
    return result;

package com.liuht.www;
​
public class Demo6 { public static void main(String[] args) {//打印全部数组
    int []arrays={1,2,3,4,5};
​
    for(int i=0;i<arrays.length;i++){
    System.out.println(arrays[i]);}
}
}

四.多维数组

package com.liuht.www;
​
public class Demo8 {
    public static void main(String[] args) {
        int [][]arrays={{1,2},{2,3},{3,4},{4,5}};
        for (int i = 0; i < arrays.length; i++) {
            for (int j = 0; j <arrays[i].length ; j++) {
                System.out.print(arrays[i][j]);
            }
​
        }
    }
​
}

五.Arrays类

数组的工具类java.util.Arrays

由于数组对象本身并没有什么方法可以供我们调用，但API中提供了一个工具类Arrays供我们使用，从而可以对数据对象进行一些基本的操作

Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用，而“不用”使用对象来调用（注意是“不用”而不是“不能”）

具有以下常用功能：

给数组赋值：通过fill方法。

对数组排序：通过sort方法，按升序

比较数组：通过equals方法比较数组中元素值是否相等

冒泡排序

package com.liuht.www;
​
import java.util.Arrays;
​
public class Demo9 {
    public static void main(String[] args) {
        int[]a={1,222,2,3,4,5,6};
         int [] sort=sort(a);
        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-1-i; j++) {
                if (array[j + 1] > array[j]) {
                    temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }
​
        }
        return array;
    }
}
​

六.稀疏数组

当一个数组中大部分元素为0，或者为同一值的数组时，可以使用稀疏数组来保存该数组。

1.记录数组一共有几行几列，有多少个不同值

2.把具有不同值的元素和行列记录在一个小规模的数组中，从而缩小程序的规模