数组定义&使用，数组的引用传递，方法声明及使用，foreach输出

数组

一维数组

数据类型是声明数组元素的数据类型，数组名是起的名称，长度存放多少元素；

//数组声明
int score[]=null;//默认值是空
score=new int[4];

int score[]=new int[10];
//声明一个元素个数位10的整型数组score，同时开辟一块内存空间供其使用；

//静态初始化
int score[]={1,2,3};

若要访问数组中的元素，利用索引来完成；

**重点：**程序内存操作流程

二维数组

数组声明

//1.
int score[][];
int score =new int[4][3];
//2.
int score[][]=new int[4][3];
//3.
int score[][]={{1,2},{3,4,5},{,6,7,8,9,10}};

public class 二维数组 {
    public static void main(String[] args) {
        int [][]age=new int[10][10];
        int count=0;
        for (int i =0;i<age.length;i++){
            for (int j=0;j<age[i].length;j++){
                age[i][j]=20+count;
                count++;
            }
        }
        print(age);
    }


    public static void print(int [][]age){
        for (int i =0;i<age.length;i++){
            for (int j=0;j<age[i].length;j++){
                System.out.print(age[i][j]+"  ");
            }
            System.out.println();
        }
    }
}

三维数组

同二维数组类比；

数组的传递引用

因为数组是引用类型， 所以，即使方法本身没有任何返回值，修改后的结果也会保留下来；
下图向方法中传递数组的过程：

方法

方法就是一段可重复调用的代码段；

方法的概念

public class 方法的概念 {

    static void hello2(){
        System.out.println("加了static可以直接调用");
    }
    void hello1 (){
        System.out.println("这是一个方法,非静态要实例化才能调用");
    }

    /**
     * @main 主方法
     * */
    public static void main(String[] args) {
        方法的概念 f=new 方法的概念();
        f.hello1();
        hello2();

    }
}

public static void printInfo(){
	
}

使用void关键字不需要任何返回值，不需要编写return语句；

方法的形参

blic class 方法的形参 {
    static void sum(int a,int b){//a,b形参
        System.out.println(a+b);
    }


    public static void main(String[] args) {
//        int a=10;
//        int b=10;
//        System.out.println(a+b);
        sum(10,20);


    }
}

方法的引用类型参数

public class 方法的引用类型参数 {

    static void init(int[]a){
        for (int i=0;i<a.length;i++){
            a[i]=i+1;
        }
    }

    public static void main(String[] args) {
        int[]b=new int[30];

        init(b);
        for (int i=0;i<b.length;i++)
            System.out.println(b[i]);
    }

}

方法的返回类型

public class 方法的返回类型 {

    static int sum(int a,int b){
        return a+b;
    }

    public static void main(String[] args) {

        int sum=sum(1,2);
        System.out.println(sum);

    }
}

方法重载

方法重载就是方法名称相同，但参数的类型和参数的个数不同；

/**
 *
 *方法重载 overlord
 * 方法名相同，但是方法的类型，以及里面的参数类型，个数不同;与返回类型无关
 * */
public class 重载 {

    static int sum(int a,int b){
        return  a+b;
    }
    static double sum(double a,double b){
        return  a+b;
    }
    static char sum(char a,char b,char c){
        return (char) (a+b+c);
    }
    public static void main(String[] args) {
        System.out.println(sum(1,2));
        System.out.println(sum(31.153,135.65400));
        System.out.println(sum('q','s','a'));
    }
}

重载注意事项：方法的重载一定只是在参数上的类型或个数不同；

方法的递归调用

public class 方法的递归调用 {
    public static void main(String[] args) {
        System.out.println(" 计算结果: "+sum(100));
    }
    public static int sum(int num){
        if (num==1){
            return 1;
        }else {
            return num+sum(num-1);
        }
    }
}

递归调用要是处理不好，有可能出现内存的溢出；

foreach输出

一般数组输出都是for循环，JDK1.5后支持一种foreach语法

public void print(){
	for(数据类型 变量名称：数组名称){
		System.out.println("");
	}	
}