java中process方法用处_脚本语言系列之Java | Java中的方法和数组

本文主要介绍java中方法、数组的定义及使用，并附上一些常见的案例，希望对java初学者有所帮助。

一、方法

假设有一个游戏程序，程序在运行过程中，要不断地发射炮弹(植物大战僵尸)。发射炮弹的动作需要编写100行的代码，在每次实现发射炮弹的地方都需要重复地编写这100行代码，这样程序会变得很臃肿，可读性也非常差。为了解决代码重复编写的问题，可以将发射炮弹的代码提取出来放在一个{}中，并为这段代码起个名字，这样在每次发射炮弹的地方通过这个名字来调用发射炮弹的代码就可以了。

上述过程中：所提取出来的代码可以被看作是程序中定义的一个方法，方法就是完成特定功能的代码块

1、方法的格式

修饰符 返回值类型 方法名(参数类型 参数名1，参数类型 参数名2…) {
            函数体;
            return 返回值;
    }

方法格式解释：

• 修饰符：比较多，后面会详细介绍，目前public static
• 返回值类型：用于限定返回值的数据类型
• 方法名： 一个名称，为了方便我们调用方法
• 参数类型：限定调用方法时传入参数的数据类型
• 参数名：是一个变量，接收调用方法时传入的参数
• 方法体：完成功能的代码
• return： 结束方法以及返回方法指定类型的值
• 返回值： 程序被return带回的结果，返回给调用者

2、如何定义一个方法

• 返回值类型：明确功能结果的数据类型
• 参数列表：明确有几个参数以及参数的类型

public static int sum(int a,int b){
        System.out.println("我是sum方法");
        return a+b;
}

3、方法的注意事项

• 方法不调用不执行
• 方法与方法是平级关系，不能嵌套定义
• 方法定义的时候参数之间用逗号隔开
• 方法调用的时候不用再传递数据类型
• 如果方法有明确的返回值，一定要有return带回一个值

4、案例

实现nn乘法表的方法

/*
    分析：
        1、确认返回值类型，void
        2、确认参数列表，n
*/

class NineNine{
    public static void main(String[] args){
        //使用双层for循环控制99乘法表的行和列的输出
        //在main方法中调用一下nn乘法表方法
        //直接调用方法
        NN(9);
        }


    public static void NN(int n){
        for(int i=1;i<n+1;i++){//控制行
            for(int j=1;j<=i;j++){ //控制列，第几行就输出几列
                System.out.print(j+"*"+i+"="+i*j+"t");//此处能换行吗？
            }
            System.out.println();
        }
    }

}

5、方法重载

在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者类型不同即可。

方法重载特点：

• 与返回值类型无关，只看方法名和参数列表（类型或者个数不同）
• 在调用时，虚拟机通过参数列表的不同来区分同名方法

class methodDemo3{
    public static void main(String[] args){
        //int value = add(12,34);
        //
        System.out.println(add(12,3,4));


    }
    //重载：方法的声明，如果完全一样是不行，也就不是重载，会报错
    //方法的参数的个数和类型要不一样才行
    public static int add(int a,int b){
        System.out.println("两个整数");
        return a+b;
    }

    public static double add(double a,double b){
        System.out.println("两个浮点型数据");
        return a+b;
    }

    public static int add(int a,int b,int c){
        System.out.println("三个整数");
        return a+b+c;
    }
}

二、数组

现在需要统计某公司员工的工资情况，例如计算平均工资、找到最高工资等。假设该公司有80名员工，用前面所学的知识，程序首先需要声明80个变量来分别记住每位员工的工资，然后在进行操作，这样做会显得很麻烦。为了解决这种问题，Java就提供了数组供我们使用。

• 数组是存储同一种数据类型多个元素的集合，也可以看成是一个容器。
• 数组既可以存储基本数据类型，也可以存储引用数据类型。

1、数组的初始化

动态初始化：初始化时只指定数组长度，由系统为数组分配初始值。

格式：数据类型[] 数组名 = new 数据类型[数组长度];

//定义了一个int类型的数组，这个数组中可以存放3个int类型的值。
int[] arr = new int[3];

静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度。

格式：数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};

//定义了一个int类型的数组，这个数组中可以存放3个int类型的值，并且值分别是1,2,3。 
int[] arr = new int[]{1,2,3};
//其实这种写法还有一个简化的写法： 
int[] arr = {1,2,3};

2、数组元素的引用

• Java中可以使用关键字new创建数组对象
• 定义并用运算符new为之分配空间后，才可以引用数组中的某个元素；
• 每个数组都有一个属性 length 指明它的长度，例如：a.length 指明数组 a 的长度(元素个数)
• 数组元素的引用方式：数组名[数组元素下标]
• 数组元素下标可以是整型常量或整型表达式。如a[3] , b[i] , c[6*i]
• 数组元素下标从0开始；长度为n的数组合法下标取值范围: 0 至 n-1（静态初始化长度：数组名.length）

public class ArrayDemo{
	public static void main(String[] args){
		//错误: 可能尚未初始化变量score
		//动态初始化
		double[] score ;
		score = new double[3];//[I@15db9742
		//对数组赋值
		score[0]=12.2;
		score[1]=12;
		score[2]=5;
		
		
		System.out.println(score);
		System.out.println(score[2]);//ArrayIndexOutOfBoundsException
		//静态初始化
		// 错误: 需要';':静态初始化的时候不能同时指定长度和初始值
		//int[] age = new int[]{12,2,3,4,6};
		//简化的写法
		int[] age = {12,3,4,5,6,7};
		String ss = "sdfasd";
		age[2]=6;
		System.out.println(age);//地址
		System.out.println(age[2]);//3
		System.out.println(age.length);
		
		
		score = null;
		System.out.println(score[0]);// java.lang.NullPointerException
	}
	
}

3、java中内存分配

栈存储局部变量，基本数据类型，引用类型变量

• 方法定义中或者方法声明上的所有变量
• 使用完毕，立即消失

堆存储new出来的东西（实体，对象）

• 每一个实体都有首地址值
• 每一个实体内的数据都有默认值

4、数组中常见异常

• 数组索引越界：ArrayIndexOutOfBoundsException ， 访问到了数组中的不存在的索引时发生。

int[] array = new int[5];
// 这将忽略第一个元素(索引0)，并在索引为5时抛出异常,这里的有效索引包含0-4。
for (int index = 1; index <= array.length; index++)
{
    System.out.println(array[index]);
}

• 空指针异常：NullPointerException，数组引用没有指向实体，却在操作实体中的元素时。

public class NullDemo{
	public static void main(String[] args){
		//定义str1为空
		String str1 = null;
		//使用str1调用字符串方法时候会抛出空指针异常
		str1.trim();
	}
}

5、数组的常见用法

a、数组遍历(依次输出数组中的每一个元素)

class ArrayBianLi{
    public static void main(String[] args){
        //数组遍历，是增强for循环
        int[] arr = {1,3,4,6,7,8,90,0};
        printArray(arr);

    }

    public static void printArray(int[] arr){
        //增强for循环
        System.out.print("[");
        for(int i:arr){
            if(i==arr[arr.length-1]){
                System.out.print(i);
            }else{
                System.out.print(i+",");
            }
        }
        System.out.print("]");
    }



}

b、数组获取最值(获取数组中的最大值最小值)

/*
    获取数组中一个最大元素：
        int[] arr = {1,3,4,6,7,8,90,0};

    通过查api文档，知道有个一数组了的方法，提供排序的功能
        1、导包java.util.Arrays
        2、static静态方法 public static void sort(int[] arr)

*/
import java.util.Arrays;
class ArrayTest3{
    public static void main(String[] args){
        //数组遍历，是增强for循环
        int[] arr = {1,3,4,6,7,8,90,0,434,3,4,56,8,234};
        //数组类中的一个方法
        //Arrays.sort(arr);
        //printArray(arr);
        //int max = arr[arr.length-1];
        //int min = arr[0];

        //写一个最大值的方法,明确两个确定
        //返回值类型是：int
        //参数列表：int[] arr
        //temp = arr[0]
        int max = getMax(arr);
        int min = getMin(arr);

        System.out.print("最大值："+max+"，最小值："+min);

    }

    public static int getMax(int[] arr){
        int max = arr[0];
        for(int i=1;i<arr.length;i++){
            if(max < arr[i]){
                max = arr[i];
            }else{
                continue;
            }

        }
        return max;
    }

    public static int getMin(int[] arr){
        int min = arr[0];
        for(int i=1;i<arr.length;i++){
            if(min > arr[i]){
                min = arr[i];
            }else{
                continue;
            }

        }
        return min;
    }

    public static void printArray(int[] arr){
        //增强for循环
        System.out.print("[");
        for(int i:arr){
            if(i==arr[arr.length-1]){
                System.out.print(i);
            }else{
                System.out.print(i+",");
            }
        }
        System.out.println("]");
    }
}

c、数组元素逆序 (就是把元素对调)

/*
    逆序算法：
    分析：
        int[] sss = {1,2,3,4,5,7,8};
        逆序：{8，7，5，4，3，2，1}

        0~arr.length-1
        1~arr.length-1-1
        2~arr.length-1-2


        m~arr.length-1-m
        条件：
            m<=length-1-m

*/
import java.util.Arrays;
class ArrayTest4{
    public static void main(String[] args){
        //数组遍历，是增强for循环
        int[] arr = {1,3,4,6,7,8,90,0,434,3,4,56,8,234,22};
        //niXu(arr);
        //printArray(arr);
        soort(arr);
        printArray(arr);
    }

    public static void niXu(int[] arr){
        for(int m=0;m<=arr.length-1-m;m++){
            int temp = arr[m];
            arr[m] = arr[arr.length-1-m];
            arr[arr.length-1-m] = temp;
        }
    }

    public static void soort(int[] arr){
        for(int i=0;i<arr.length-1;i++){
            for(int j=0;j<arr.length-1-i;j++){
                if(arr[j]<arr[j+1]){
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }

    }



    public static void printArray(int[] arr){
        //增强for循环
        System.out.print("[");
        for(int i:arr){
            if(i==arr[arr.length-1]){
                System.out.print(i);
            }else{
                System.out.print(i+",");
            }
        }
        System.out.println("]");
    }
}

d、数组的冒泡排序

/*
    冒泡排序：
        1、相邻的两个数比较，较大者往后拍（前面大后面下需要交换一下）,总共需要进行arr.length-1轮
        2、第一次，总共需要比较arr.length-1
        3、第二次需要比较arr.length-2
        4、第n次需要比较的次数：arr.length-n

*/
import java.util.Arrays;
class ArrayTest6{
    public static void main(String[] args){
        //快速排序
        int[] arr = {1,3,4,6,7,8,90,0,434,3,4,56,8,234,22};
        maoPao(arr);
        printArray(arr);
    }

    //冒泡排序方法
    //确定返回值类型：因为是引用数据类型，对数组的改变，直接影响传入的参数，不用专门的返回数组
    //参数列表：是int[] arr
    public static void maoPao(int[] arr){
        for(int i=0;i<arr.length-1;i++){//表示冒泡排序的轮次
            //每实现一次内层for循环的效果：前面最大的值排到了后面
            for(int j=0;j<arr.length-1-i;j++){//每一轮的时候需要进行的相邻的两两比较
                if(arr[j]>arr[j+1]){
                    //第一种交换方式
                    //int temp = arr[j];
                    //arr[j] = arr[j+1];
                    //arr[j+1] = temp;

                    //第二种
                    //arr[j] = arr[j] ^arr[j+1];
                    ///arr[j+1] = arr[j] ^arr[j+1];
                    //arr[j] =arr[j] ^arr[j+1];

                    //第三种
                    //arr[j] = arr[j] + arr[j+1];
                    //arr[j+1] = arr[j] - arr[j+1];
                    //arr[j] =arr[j] - arr[j+1];

                    //第四种,一句话搞定
                    arr[j] = arr[j] + arr[j+1] -(arr[j+1] = arr[j]);
                }
            }
        }
    }

    public static void printArray(int[] arr){
        //增强for循环
        System.out.print("[");
        for(int i:arr){
            if(i==arr[arr.length-1]){
                System.out.print(i);
            }else{
                System.out.print(i+",");
            }
        }
        System.out.println("]");
    }
}

---

欢迎关注作者，如果觉得写的还不错，就给点个赞同、喜欢、收藏（后续持续更新）。

【全文手打 如需转载 请标注此出处】