Java方法与数组介绍

方法

方法的定义

方法（又叫函数）就是一段特定功能的代码块。方法提高程序的复用性和可读性。比如，有了方法，我们就可以把要重复使用的一段代码提炼出来，然后在每个需要执行这段代码的地方去调用即可。

方法的格式

访问权限修饰符[其他的修饰符 如stack] 返回值类型 方法名[参数类型1 形参1，参数类型2 形参2，...]{
//形参列表
//方法体
return 返回值；
}

方法的格式说明：
修饰符：目前就用public static。
返回值类型：就是功能结果的数据类型。
方法名：见名如意，首字母小写，遵守驼峰命名法。

实参与形参

形参（方法定义上的，用于接收实际参数的）就是一个变量，实参（实际参与运算的）就是一个值，传参就是把一个值给一个形参赋值。在调用方法中，如果我们定义的方法有参数，就必须在调用方法的同时传入这个值，即给当前方法中的参数赋值，而这个传入的值我们称为实际参数，也就是实参。
实参：传入的参数值
形参：接收实参传过来的值
注意：实参名与形参名可以相同，也可以不同

方法的返回值

return：结束方法的
返回值：就是功能的结果，由return 带给调用者。
注意：
1.若当前方法没有返回值类型，即返回值类型是void，那么当前方法中可以不写return；
2.return即表示结束一个方法，也可以将返回值返回给调用当前方法的调用者；
3. return返回值时一次只能返回一个值，不可以返回多个值。
4.一个方法中可以有多个return，但被执行的只能有一个，所以需要判断
【例子1】

package HeadFirst;

public class Test {
    public static void main(String[] args) {
        boolean bool=isRunNian(2017);
        if(bool) {
            System.out.println("闰年");
        }else {
            System.out.println("平年");
        }
        print();
        }
    public static boolean isRunNian(int year){
        if ((year%4==0 && year%100!=0) || year%400==0) {
            return true;
        }else{return false;
        }
    }
    public static void print(){
        for (int i=0;i<10;i++){
            if(i==5){
                return;//表示方法结束
            }
            System.out.println(i);
        }
    }
}

【例子2】

package HeadFirst;

import java.util.Scanner;

public class Test1 {
    public static void main(String[] args) {
        Scanner input=new Scanner(System.in);
        System.out.println("请输入三角形的行数：");
        int num=input.nextInt();
        printTriangle(num);
    }
    public static void printTriangle(int line){
        //外循环控制行数
        for (int i=1;i<line;i++){
            //内循环输出空格
            for(int j=i;j<line;j++){
                System.out.print(" ");
            }
            //内循环输出*
            for (int j=1;j<=i*2-1;j++){
                System.out.print("*");
            }
            System.out.println();
        }

    }
}

方法的重载（overriding）

在类中可以创建多个方法，它们具有相同的名字，但具有不同的参数和不同的定义。
返回值不能作为重载的条件。
如：
public void method(int a){…}
public void method(char c){…}
【例子】

package HeadFirst;
/*
方法重载
 */
public class Test2 {
    public static void main(String[] args) {
        int result=add(10,20);
        System.out.println(result);
    }
    public static int add(int a,int b){
        return a+b;
    }
    public static float add(float a,float b){
        return a+b;
    }
    public static float add(int a,float b){
        return a+b;
    }
}

Java数组

数组的定义：一组能够存储相同数据类型值的变量的集合。当我们有一组相同类型的数据需要存储，如果此时使用单个变量来存储，我们将要定义若干个变量名，这样将会非常繁琐，不利于维护。
数组的赋值方式：
四种：
一、 使用默认的初始值来初始化数组中的每一个元素
语法：数组元素类型 [ ] 数组名=new 数组元素类型[数组中元素 的个数（数组的长度）];
如：int [ ] scores=new int[3];
二、 先声明，然后再赋予默认的初始值。
语法：数组元素类型 [ ]数组名；
数组名=new 数组元素类型[数组中元素 的个数（数组的长度）];
如：int [ ] scores;
scores=new int[3];
三、 先声明，然后 再使用指定的值进行初始化
语法：数组元素类型 [ ]数组名=new 数组元素类型[ ]{元素1，元素2，…}；
如：int [ ] scores=new int [ ] {56,78,98}；
四、 将第三种写法可以简化为（使用数组常量值给数组进行赋值）
语法：数组元素类型 [ ]数组名={元素1，元素2，…}；
如：int [ ] scores={56,78,98}；
【例子】

package HeadFirst;
/*
数组的定义：一组能够存储相同数据类型的数据集合
数组一定要有长度
数组中的每个数据称为元素，数组元素的位置从0开始，数组中的位置称为下标
 */
public class Test3 {
    public static void main(String[] args) {
        //第一种
        int [] nums = new int[5];
        /*
        nums[0]=1;
        nums[1]=2;
        nums[2]=3;
        nums[3]=4;
        nums[4]=5;
         */
        for (int i=0;i<nums.length;i++){
            nums[i]=i+1;
        }
        //第二种
        int [] nums2;//先声明（定义）
        nums=new int[5];
        //第三种
        int [] nums3=new int[]{1,2,3,4,5};
        //第四种,为第三种方法的缩写
        int [] nums4={1,2,3,4,5};
        //所有的数组都有一个属性是：length
        System.out.println("数组的长度是："+nums4.length);
    }
}

数组的遍历

求数组的长度：
x.length
通过下标来访问数组中的元素。
下标：从0开始，到数组长度-1
如：int [] scores={89,90};
访问最后一个元素值：int lastElement=scores[scores.length-1];

遍历：依次取出数组中的每一个元素。
遍历方式一：普通的for 循环

语法：for (int i=0;i<数组的长度;i++){
//i：循环变量，同样：也是数组的下标（取值范围[0,数组长度]）
		数组中元素的类型 变量=数组名[i];
}

【例子】

增强for 循环与可变参数

1.5以后java新增for each循环和可变参数

遍历方式二：使用增强for 循环【for each循环】

语法：for(数组中元素的类型 变量：数组名){
		数组中元素的类型  临时变量=变量；
		}
综合方法的定义，可以使用可变参数来代替数组作为参数。
public static void print (int ... 变量名){
			//可变参数在使用时作为数组使用
}

使用数组要注意的问题：
空指针异常（NullPointerException）
数组越界异常（ArrayIndexOutOfBoundsException）

数组内存结构分析：数组是引用类型，会存放在堆内存中。（详细说就是，栈（栈内存大小固定，用于存储局部，临时变量（基本数据类型）和引用变量）中存放数组的地址，该地址是指向堆空间，也就是地址引用了堆（堆内存，大小不固定：对象）里面的空间）
【例子】

package HeadFirst;

import sun.awt.windows.WPrinterJob;

public class Test4 {
    public static void main(String[] args) {
        int[] scores = {59, 75, 83, 93, 100};
        System.out.println("数组的长度：" + scores.length);
        //遍历，通过遍历方法输出数组的各个元素
        int len = scores.length;//直接先定义一个变量用来存数组的长度，提高效率，避免下面循环时一次又一次求数组长度
        for (int i = 0; i < len; i++) {
            int score = scores[i];
            System.out.println(score);
            System.out.println("--------------");
            //foreach JDK1.5后新增的特性
            for (int x : scores) {
                System.out.println(x);
            }
        }
        //调用方法
        System.out.println("--------------");
        print(scores);
        print2(59, 75, 83, 93, 100);
        print3(null);
        print4(scores);
    }

        public static void print(int[] x){
            int len1=x.length;
            for(int i=0;i<len1;i++){
                System.out.println(x[i]);
            }
        }
        //JDK1.5可变参数
        //可变参数只能是参数列表中的最后一个
        //可变参数作为数组使用
        public static void print2(int k,int... x){//这样定义的可变参数，元素59会赋给k,剩下的都赋给可变参数x
            int len2=x.length;
            for (int i=0;i<len2;i++){
                    System.out.println(x[i]);
            }
        }
        //测试数组的异常NullPointerException（空指针）
    public static void print3(int[] x){
        //java.lang.NullPointerException
        //当一个变量为null（没有赋值）时，我们去调用了改变量的属性和方法
        System.out.println("数组的长度为："+x.length);
    }
    //测试数组的异常，数组下标越界
    //java.lang.ArrayIndexOutOfBoundException
    public static void print4 (int [] x){
        for (int i=0;i<=x.length;i++){
            System.out.println(x[i]);
        }
    }


    }

数组示例

1.猜数游戏：从键盘中任意输入一个数据，判断数列中是否包含次数
【代码】

package HeadFirst;
/*
数组示例：1、猜数游戏：从键盘中任意输入一个数据，判断数列中是否包含次数
 */
import java.util.Scanner;
import java.util.Random;
public class Test5 {
    public static void main(String [] args){
       // int[] nums={30,17,6,2,22,27};
        int[] nums=new int[5];
        int len=nums.length;
        Random r=new Random();//创建一个可以生成随机数的工具
        for(int i=0;i<len;i++){
            nums[i]=r.nextInt(50);
        }

        Scanner input=new Scanner(System.in);
        System.out.println("请输入你要猜的数：（50以内）");
        int userNum=input.nextInt();

        boolean flag=false;
        for (int x:nums){
            if(userNum==x){
                flag=true;
                break;
            }
        }
        if(flag){
            System.out.println("恭喜你，猜对了");
        }else{
            System.out.println("没猜对，加油！");
        }

    }
}

2.打印正三角形。

package HeadFirst;
/*
数组示例：打印正三角形。
 */
public class Test6 {
    public static void main(String[] args) {
        char[] cs={'A','B','C','D','E','F','G'};
        int len=cs.length;

        for (int i=1;i<=len;i++){
            for (int j=i;j<len;j++){
                System.out.println(" ");
            }
            for(int j=1;j<=i*2-1;j++){
                System.out.print(cs[i-1]);
            }
            System.out.println();

        }
    }
}

3.多维数组示例
【代码】

package HeadFirst;
/*
二维数组示例：Java中没有真正的多维数组，多维数组的表示方式是数组中的元素还是数组
有3个班级各3名学员参赛，记录每个学员的成绩，并计算每个班的平均分
 */
import java.util.Scanner;
public class Test7 {
    public static void main(String[] args) {
        int [][]scores={{78,98,88},{87,96,85},{67,78,89}};
        int classLen=scores.length;
        for(int i=0;i<classLen;i++){
            int sum=0;
            int count=scores[i].length;
            for(int j=0;j<count;j++){
                sum+=scores[i][j];
            }
            int avg=sum/count;
            System.out.println("第"+(i+1)+"班的平均成绩是："+avg);
        }
    }
}