java 方法&数组

落日映苍穹つ 2022-12-15 14:10 221阅读 0赞

## java 方法&数组 ##

### 文章目录 ###

*   *  java 方法&数组
     *   *  一、方法
         *  \*\*1.1\*\* \*\*方法概述\*\*
         *  1.2 方法的定义
         *   *  1.2.2例题求两数之和
         *  1.3 有明确返回值的方法调用
         *  \*\*1.4\*\* \*\*没有明确返回值的方法调用\*\*
         *  \*\*1.5\*\* \*\*方法重载\*\*
         *   *  1.5.1 方法重载概述
             *  1.5.2\*\*方法重载的特点\*\*
         *  二、数组
         *   *  2.1 数组概述
             *  2.2 数组的初始化
             *  2.3 动态初始化
             *  2.4 静态初始化
             *  2.5数组中常见的两个小问题
             *  例题：
             *  2.6冒泡排序算法
             *  2.7选择排序
             *  2.8二维数组
             *   *  2.8.1 二维数组概述
                 *  2.8.2二维数组定义格式
                 *  2.8.3杨辉三角

### 一、方法 ###

### **1.1** **方法概述** ###

方法：就是将一个功能抽取出来，把代码单独定义在一个大括号内，形成一个单独的功能。 当我  
们需要这个功能的时候，就可以去调用。这样即实现了代码的复用性，也解决了代码冗余的现象。  
(方法就是完成特定功能的代码块)

### 1.2 方法的定义 ###

定义格式：

修饰符 返回值类型 方法名 （参数列表）
    ｛ 代码（方法体）... 
       return ; ｝

定义格式解释：

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

规则：

1）返回值类型 明确功能结果的数据类型  
修饰符 返回值类型 方法名 （参数列表）｛ 代码（方法体）… return ; ｝  
2）参数列表 明确有几个参数，以及参数的类型

#### 1.2.2例题求两数之和 ####

public class Method_Demo2 
    { 
         public static void main(String[] args) 
    { // 调用方法getSum，传递两个整数，这里传递的实际数据又称为实际参数 
     // 并接收方法计算后的结果，返回值 
       int sum = getSum(5, 6); 
       System.out.println(sum); 
    }
    /*定义计算两个整数和的方法 返回值类型，
    计算结果是int 参数：不确定数据求和，
    定义int参数.参数又称为形式参数 */ 
      public static int getSum(int a, int b)
    {
        return a + b; 
    } 
    }

### 1.3 有明确返回值的方法调用 ###

**有明确返回值的方法调用：**  
单独调用，没有意义  
输出调用，有意义，但是不够好，因为我不一定非要把结果输出  
赋值调用，推荐方式

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

**例题：**

1.  键盘录入两个数据，返回两个数中的较大值
2.  键盘录入两个数据，比较两个数是否相等
3.  键盘录入三个数据，返回三个数中的最大值

import java.util.Scanner;
    
    public class HomeTest {
    
     
        public static void main(String[] args) {
            
             Scanner src = new Scanner(System.in);
    	
    		System.out.println("请输入第一个 int 类型数据:");
    		int n1= src.nextInt();
    		System.out.println("请输入第二个 int 类型数据:");
    		int n2= src.nextInt();
    		System.out.println("请输入第三个 int 类型数据:");
            int n3=src.nextInt();
    
    		System.out.println("请输入第一个 int 类型数据:");
    		int m= src.nextInt();
    		System.out.println("请输入第二个 int 类型数据:");
    		int n= src.nextInt();
    		System.out.println("请输入第一个 int 类型数据:");
    		int x= src.nextInt();
    		System.out.println("请输入第二个 int 类型数据:");
    		int y= src.nextInt();
    		System.out.println("请输入第三个 int 类型数据:");
            int z=src.nextInt();
            
            //调用已经写好的方法 将实参传递进去
    		int max =getMax(n1,n2,n3);//实参 ：n1 , n2 , n3由键盘录入的数据 
    		boolean flag =compare(m,n);
    		int max2=getMax1(x,y,z);
    		
    		//有返回值方法的输出 由赋值调用法输出
    		System.out.println("Rusult1:"+max );
    		System.out.println("------------------------" );
    		System.out.println("Rusult:2"+flag);
    		System.out.println("------------------------" );
    		System.out.println("Rusult3:"+max2 );
    	
            
        
    	}
    	//方法一：三目运算法
    	//比较三个数最大值
    	//有明确返回值类型的方法
    	public static int getMax(int a,int b, int c)
    		{   
    			int temp = (a > b) ? a : b ;
    		     int max = (temp > c) ? temp : c ;
    		     return max ;
    		}
    		//判断两个数是否相等
    		public  static boolean compare(int a,int b)
    		{   
    		    //
    			return (a == b)?true:false;
    		}
    		//方法二：if....else
    		//比较三个数最大值
    		public static int getMax1(int a, int b, int c)
    		{
    			int max1 = 0;
    			if(a >b)
    			{
    				if(a>c)
    				{
    					max1 = a;
    				}else{
    					max1 = c;
    				}
    			}else
    			{
    				if(b > c)
    				{
    					max1 = b;
    				}else{
    					max1 = c;
    				}
    			}
    			return max1;
    		}
    }

### **1.4** **没有明确返回值的方法调用** ###

没有明确返回值的函数调用
    其实就是void类型方法的调用
    只能单独调用

**例题：**

1. 键盘录入行数和列数，输出对应的星形
    2. 键盘录入一个数据n(1<=n<=9)，输出对应的nn乘法表

import java.util.Scanner;
    class NoReturnDemo
    {
    	public static void main(String [] args)
    	{   
    	    //创建键盘录入对象
    		Scanner src = new Scanner(System.in);
    		
    		//5行4列的星星矩阵
    		//原始方法
    		for(int i = 0; i <=5 ;i++)
    		{
    			for(int a = 0; a <=4; a++ )
    			{
    				System.out.print("*");
    			}
    			System.out.println();
    		}
    		System.out.println("-----------------------");
    		
    		//设定了 一个 打印*矩阵的 无返回值方法 现在进行 传参 就可进行使用
    		printStar(4,9);
    		System.out.println("-----------------------");
    		//由键盘录入想打印几几乘法表的列数，并由定义好的方法实现
    	    System.out.println("请您输入数列：");
    		int k =src.nextInt();
    		NN(k);
    	}
    	//无返回值的NN乘法表方法
    	public static void NN(int k)
    	{
    		for(int w = 1; w <= k;w++)
    		{
    			for(int r=1; r <=w; r++)
    			{
    				System.out.print(w+"*"+r+"="+(w*r)+"\t");
    			}
    			System.out.println();
    		}
    	}
    	//打印*的方法
    	public static void printStar(int m, int n)
    	{
    		for(int x = 0; x <=m ;x++)
    		{
    			for(int y = 0; y <=n; y++ )
    			{
    				System.out.print("*");
    			}
    			System.out.println();
    		}
    	}
    }

### **1.5** **方法重载** ###

#### 1.5.1 方法重载概述 ####

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

#### 1.5.2**方法重载的特点** ####

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

\*\*例题：\*\*判断哪些方法是重载关系。

public static void open(){} //正确重载
    public static void open(int a){} //正确重载
    static void open(int a,int b){} //与第8个冲突
    public static void open(double a,int b){} 正确重载
    public static void open(int a,double b){}//与第6个冲突
    public void open(int i,double d){} //与第五个冲突
    public static void OPEN(){} //它不报错，但它不是重载
    public static void open(int i,int j){}//与第3个冲突

### 二、数组 ###

#### 2.1 数组概述 ####

**数组概念：**  
数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器。  
数组既可以存储基本数据类型，也可以存储引用数据类型。  
数组定义的格式：

格式1：数据类型\[\] 数组名;  
格式2：数据类型 数组名\[\];  
注意：这两种定义做完了，数组中是没有元素值的。

#### 2.2 数组的初始化 ####

**数组初始化概述：**  
Java中的数组必须先初始化,然后才能使用。  
所谓初始化：就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。  
**数组的初始化方式：**  
动态初始化：初始化时只指定数组长度，由系统为数组分配初始值。  
静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度。

#### 2.3 动态初始化 ####

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

格式：
    数据类型[] 数组名 = new 数据类型[数组长度];
    数组长度其实就是数组中元素的个数。
    
    举例：
    int[] arr = new int[3];
    解释：定义了一个int类型的数组，这个数组中可以存放3个int类型的值。

#### 2.4 静态初始化 ####

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

格式：
    数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};
    举例：
    int[] arr = new int[]{1,2,3};
    解释：定义了一个int类型的数组，这个数组中可以存放3个int类型的值，并且值分别是1,2,3。
    其实这种写法还有一个简化的写法
    int[] arr = {1,2,3};

#### 2.5数组中常见的两个小问题 ####

数组越界异常  
原因：使用数组时数组的索引值超出了数组的长度范围  
解决：修改角标值即可。  
空指针异常  
原因：空指针异常,大部分就是你在使用对象的时候这个对象是一个null值.这时就会报出空指针异常.  
解决：有一个null的对象调用了方法,使得系统提示空指针异常.那么就修改对应的出现了null的对象.

#### 例题： ####

1)自定义一个数组,静态初始化 ,将数组遍历(依次输出数组中的每一个元素),将遍历使用功能完成!  
输出的格式：\[元素1,元素2，元素3…\]

class ArryDemo3
    {
    	public static void main(String [] args)
    	{int [] arr1 = {121,123,143,145,156,2244,555,667,887,88,99,2,3,4,5,6,9};
    		 System.out.println(arr1.length);
    		 System.out.println("----------------------------------------");
    		 printArry(arr1);
    	}
    	//定义一个无返回值类型的方法 
    	//遍历数组
    	public static void printArry(int []arr1)
    	 {
    		 System.out.print("{") ;
    		 for(int i=0; i<arr1.length; i++)//i是索引(角标)
    		 {
    		 
    			if(i == arr1.length -1){
    				
    				System.out.println(arr1[i] +"}") ;
    			}else{
    				
    				System.out.print(arr1[i] +", ") ;
    			}
    		 
    		 }
    	 }
    	}

2)自定义数组\{13,87,24,65,15\}，获取获取最值(获取数组中的最大值最小值),将获取的最大值和最小值分别使用功能完成!

//无返回值方法实现
    import java.util.Scanner;
    class FunctionDemo1
    {
    	public static void main(String [] args)
    	{
    		int [] arr = {13,87,24,65,15};
    		
    		compareMax(arr);
    		compareMin(arr);
    	}
    	public static void compareMax(int [] arr)
    	{
    		int index=0;
    	    int max=arr[index];
    		for(int i=0;i<arr.length;i++)
    		{
    			if(arr[i]>max)
    		{
    			//index = i;
    			max =arr[i];
    		}
    		
    		}
    		System.out.println("max:"+max);
    	}
    	public static void compareMin(int [] arr)
    	{
    		int index=0;
    	    int min=arr[index];
    		for(int i=0;i<arr.length;i++)
    		{
    			if(arr[i]<min)
    		{
    			//index = i;
    			min =arr[i];
    		}
    		
    		}
    		System.out.println("min:"+min);
    	}
    }

3)查询数组中的元素在数组索引值

/*
    	数组的元素基本查找:
    	   查询数组中的元素在数组索引值!  (有一定的耗时:从头查到末尾)
    	   
    	   查询的数组: 可以无序的,也可以有序
    	   {11,22,33,44,55} ; 有序的
    	   {13,87,65,24,57} ;//无序
    	   
    	   
    	  假设:
    		int[] arr =   {13,87,65,24,57}  ;
    		
    		查询65这个元素在数组中的出现的索引值!
    */
    
    class ArrayTest5{
    	public static void main(String[] args){
    		
    		//创建一个数组,静态初始化
    		int[] arr =   {13,87,65,24,57}  ;
    		
    		//1)查询65这个元素在数组中的出现的索引值!（使用方法來完成）
    		int index = getIndex(arr,65) ;
    		System.out.println("index:"+index) ;
    		System.out.println("------------") ;
    		int index2 = getIndex(arr,650) ;
    		System.out.println("index2:"+index2) ;
    		System.out.println("------------") ;
    		
    		int index3 = getIndex2(arr,300) ;
    		System.out.println("index3:"+index3) ;
    		System.out.println("------------") ;
    		int index4 = getIndex2(arr,13)  ;
    		System.out.println("index4:"+index4) ;
    	}
    	
    	//方式2:
    	/*
    		假设思想:
    			1)假设找不到   
    				定义一个变量 
    				int index = -1 ;
    			2)遍历数组,获取到每一个元素
    				如果当前元素和要查询的元素一致的话
    						改变index的值(将当前元素所在的角标值赋值给index)
    						break ;
    						
    			3)找不到,直接返回index
    	*/
    	public static int getIndex2(int[] arr,int key){
    		//假设找不到   
    		int index = -1 ;
    		//遍历arr数组
    		for(int x = 0 ; x < arr.length ; x ++){
    			//获取到每一个元素
    			//和key进行比较
    			if(arr[x] == key){
    				//找到了,改变index的值
    				index = x ;
    				break ;
    			}
    		}
    		return index ;
    	}
    	
    	/*
    		两个明确:
    		  1)明确返回值类型: int类型
    		  2)明确参数类型以及参数个数:
    		        int类型  两个参数: int[] arr , int key(元素)
    	*/
    	//参数1:要查询的数组
    	//参数2:要查询的元素
    	//方式1
    	public static int getIndex(int[] arr,int key){
    		//1)先去遍历arr数组
    		for(int x = 0 ; x < arr.length ; x ++){
    			//每一个元素都获取到了
    			//如果arr[x] 和可以 相等的话
    			//直接返回x :角标即可!
    			if(arr[x] == key){ //查询到了,返回x
    				return x ;
    			}
    		}
    		//写逻辑判断:
    			//两种:true,成立
    			//false,不成立
    
    			//如果找不到,Java中给定一个负数即可!
    			return -1 ;
    	}
    }

4)数组中元素逆序

/*
    	数组的应用:
    			数组的元素逆序	
    	int[] arr = {13,87,65,24,57} ;
    	
    	中心思想:
    		将13  arr[0]--57 arr[arr.length-1]互换
    		将87 arr[1]---24 arr[arr.length-1-1]互换....
    		...
    		保证  数组的长度/2		
    	
    */
    
    class ArrayTest3{
    	public static void main(String[] args){
    			
    			//创建一个数组,静态初始化!
    			int[] arr = {13,87,65,24,57} ;
    			System.out.println("数组逆序前:  ") ;
    			printArray(arr) ;
    			System.out.println("----------------") 
    			System.out.println("数组逆序后:  ") ;
    			reverse(arr) ;//逆序方法
    			printArray(arr) ;//遍历(输出结果)
    			
    			
    	}
    	
    	
    	//定义一个方法:逆序的方法
    	//两个明确
    	//明确返回值类型:没有具体返回值类型 void代替
    	//明确参数类型以及参数个数:int[] arr
    	public static void reverse(int[] arr){
    	
    		//遍历数组:保证角标值小于数组长度/2
    		for(int x = 0 ; x < arr.length/2 ; x ++){
    			//中间变量方式互换
    			int temp = arr[x] ;
    			arr[x] = arr[arr.length-1-x] ; //后面的元素和前面的互换
    			arr[arr.length-1-x] = temp ;
    		}
    		
    		
    	}
    	
    	
    	
    	//数组的遍历功能:
    	public static void printArray(int[] arr){
    		System.out.print("[") ;
    		for(int x = 0 ; x < arr.length ; x ++){
    			//判断
    			if(x == arr.length-1){
    				System.out.println(arr[x]+"]") ;
    			}else{
    				System.out.print(arr[x] +", ") ;
    			}
    		}
    	}
    }

5）数组元素查表法

/*
    	数组元素查表法
    	
    			数组名称[index:角标]访问元素
    	
    	假设:
    		字符串数组:  数据类型[] 数组名称 = new 数据类型[]{元素1,....} ;
    		String[] strs = {"星期一","星期二",
    						"星期三","星期四","星期五","星期六","星期天"} ;
    	
    需求:键盘录入数据:查询当前星期几
    */
    //导包
    import java.util.Scanner ;
    class ArrayTest4{
    	public static void main(String[] args){
    		
    		//字符串数组
    		String[] strs = {"星期一","星期二",
    						"星期三","星期四","星期五","星期六","星期天"} ;
    		
    		//创建键盘录入对象
    		Scanner sc = new Scanner(System.in) ;
    		
    		//提示并录入数据
    		System.out.println("请您输入一个数据(0-6):") ;
    		int index = sc.nextInt() ;
    		
    		System.out.println("你要查询的是:"+strs[index]) ;
    	}
    }

#### 2.6冒泡排序算法 ####

冒泡排序思想 
    		
    两两比较,将较大的值往后放;第一次比较完毕,最大值就出现在最大索引处!
    依次这样比较:
    		
    	规律:
    		第一次:有0个不比
    	    第二次:有1个不比
    		...
    		...
    		比较的次数:数组长度-1次

class WayOfMaopao
    {
    	public static void main(String[] args)
    	{ //定义数组，静态初始化
    		int []arr ={24, 69 , 87 ,57,13};
    		System.out.println("排序前：");
    		printArry(arr);
    		System.out.println("---------");
    		System.out.println("排序后：");
    		sort(arr);
    		printArry(arr);
    	}
    	public static void printArry(int [] arr)
    	{
    		System.out.print("[");
    		for(int  i = 0; i<arr.length-1 ; i++)
    		{
    			if(i==arr.length -1)
    			{
    			System.out.println(arr[i]+"]");
    			}else
    			{
    				System.out.print(arr[i]+" ,");
    			}
    		
    		}
    	}
    	public static void sort(int []arr)
    	{
    		for(int x =0; x< arr.length-1;x++)
    		{
    			for(int y=0; y<arr.length-1-x;y++)
    			{
    				if(arr[y]>arr[y+1])
    				{
    					int temp = arr[y];
    					arr[y] = arr[y+1];
    					arr[y+1] =temp;
    				}
    			}
    		}
    	}
    }

#### 2.7选择排序 ####

package com.qianfeng_array;
    /*
     * 选择排序的思想:
     * 		使用数组中0角标对应的元素依次和后面元素进行比较,小的值往前放,
     * 第一次比较完毕,最小值出现在最小索引处,依次这样比较,1角标对应的元素依次和后面元素比较.... ...
     * 
     * 规律:
     * 		比较的次数:数组长度-1次
     * */
    public class ArrayDemo {
    
    	public static void main(String[] args) {
    		
    		//创建一个数组,静态初始化
    		int[] arr = {87,69,57,13,24} ;
    		
    		//排序之前
    		System.out.println("排序之前:");
    		//遍历 的功能
    		printArray(arr) ;
    		System.out.println("----------------------------");
    		//单独调用
    		System.out.println("使用方法完成,排序后:");
    		selectSort(arr);
    		
    		//遍历
    		printArray(arr);
    	
    	}
    	
    	//方法定义
    	public static void selectSort(int[] arr) {
    		for(int x = 0 ; x < arr.length-1 ;x ++) {//x=0,1,2,3
    			for(int y = x +1 ; y < arr.length ; y ++) { //将元素一一获取进行排序
    				if(arr[y] < arr[x]) {
    					int temp = arr[x] ;
    					arr[x] = arr[y] ;
    					arr[y] = temp ;
    				}
    			}
    		}
    	}
    
    	//遍历的功能
    	public static void printArray(int[] arr) {
    		System.out.print("[");
    		for(int x = 0 ; x < arr.length ; x ++) {
    			//判断
    			if(x == arr.length-1) {
    				System.out.println(arr[x] + "]");
    			}else {
    				System.out.print(arr[x] +", ");
    			}
    		}
    	}
    }

#### 2.8二维数组 ####

##### 2.8.1 二维数组概述 #####

Java基础班每个班有很多个学生，所以，可以用数组来存储，而我们又同时有很多个Java基础班。这个也应该用一  
个数组来存储。如何来表示这样的数据呢?Java就提供了二维数组供我们使用。 由此可见：其实二维数组其实就是  
一个元素为一维数组的数组。

##### 2.8.2二维数组定义格式 #####

格式1

数据类型[][] 变量名 = new 数据类型[m][n];
    m表示这个二维数组有多少个一维数组
    n表示每一个一维数组的元素个数 
    举例： int[][] arr = new int[3][2]; 
    定义了一个二维数组arr 
    这个二维数组有3个一维数组，
    名称是arr[0],arr[1],arr[2] 
    每个一维数组有2个元素，
    可以通过arr[m][n]来获取 表示获取第m+1个一维数组的第n+1个元素

格式2

数据类型[][] 变量名 = new 数据类型[m][];
    m表示这个二维数组有多少个一维数组 
    这一次没有直接给出一维数组的元素个数，可以动态的给出。 
    举例： 
    int[][] arr = new int[3][]; 
    arr[0] = new int[2]; 
    arr[1] = new int[3] ;
    arr[2] = new int[1];

格式3

数据类型[][] 变量名 = new 数据类型[][]{
       {元素…},{元素…},{元素…}};
    简化版格式： 数据类型[][] 变量名 = {
       {元素…},{元素…},{元素…}}; 
    举例： int[][] arr = {
       {1,2,3},{4,6},{6}};

##### 2.8.3杨辉三角 #####

/*
    二维数组的应用:杨辉三角形
    输出:
    1
    1 1
    1 2 1
    1 3 3 1 
    1 4 6 4 1 
    1 5 10 10 5 1
    
    //导包
    import java.util.Scanner ;
    class Array2Test{
    	public static void main(String[] args){
    		
    		//创建键盘录入对象
    		Scanner sc = new Scanner(System.in) ;
    		
    		//提示并接收数据
    		System.out.println("请您输入一个数据:") ;
    		int n = sc.nextInt() ;
    		
    		//定义二维数组,动态初始化
    		int[][] arr = new int[n][n] ;
    		
    		//给二维数组中的数据赋值(给任何的一列和最后一列赋值) 
    		//将定义二维数组遍历
    		for(int x = 0 ; x < arr.length ; x ++){
    			//赋值 
    			//任何的一列和最后一列都是1
    			arr[x][0] = 1 ;
    			arr[x][x] = 1 ;
    		}
    		
    		for(int x = 2 ;x < arr.length ; x ++){
    			//内层循环
    		
    			for(int y = 1 ; y <=x -1; y ++){
    				//中间的数据的值等于上一行的前一列+上一行的本列之和
    				arr[x][y] = arr[x-1][y-1] + arr[x-1][y] ;
    				
    			}
    		}
    		
    		//跟99乘法表规律:y的角标值 y<=x 的值
    		for(int x = 0 ; x < arr.length ; x ++){
    			for(int y = 0 ; y <=x ; y ++){ //x = 0 (第一行), y=0(第一列)  ,y<=1(0,1)
    				System.out.print(arr[x][y] +"\t") ; //arr[0][0] arr[1][1]
    			}
    			System.out.println() ;
    		}
    	}
    }

**例题：**

公司年销售额求和  
某公司按照季度和月份统计的数据如下：单位(万元)  
第一季度：22,66,44  
第二季度：77,33,88  
第三季度：25,45,65  
第四季度：11,66,99

import java.util.Scanner;
    class ArryDemo
    {
    	public static void main(String[] args)
    	{
    		int [][]arr = {
       {22,66,44},{77,33,88},{25,45,65},{11,66,99}};
    		int sum=printArry(arr);
    		System.out.println("sum:"+sum);
    		//printArry1(arr);
    	}
    	public static int  printArry(int [][]arr)
    	{
    		int sum = 0;
    	for(int i = 0; i<arr.length;i++)
    	{
    		
    			for(int x = 0;x<arr[i].length;x++)
    		{   
    	        sum +=arr[i][x];
    		}
    	}
    	   return sum;
    	}  
    }

\]\[y\] ;

}
    	}
    	
    	//跟99乘法表规律:y的角标值 y<=x 的值
    	for(int x = 0 ; x < arr.length ; x ++){
    		for(int y = 0 ; y <=x ; y ++){ //x = 0 (第一行), y=0(第一列)  ,y<=1(0,1)
    			System.out.print(arr[x][y] +"\t") ; //arr[0][0] arr[1][1]
    		}
    		System.out.println() ;
    	}
    }

**<u>例题：</u>**
    
    公司年销售额求和
    	某公司按照季度和月份统计的数据如下：单位(万元)
    	第一季度：22,66,44
    	第二季度：77,33,88
    	第三季度：25,45,65
    	第四季度：11,66,99

import java.util.Scanner;  
class ArryDemo  
\{  
public static void main(String\[\] args)  
\{  
int \[\]\[\]arr = \{ \{22,66,44\},\{77,33,88\},\{25,45,65\},\{11,66,99\}\};  
int sum=printArry(arr);  
System.out.println(“sum:”+sum);  
//printArry1(arr);  
\}  
public static int printArry(int \[\]\[\]arr)  
\{  
int sum = 0;  
for(int i = 0; i<arr.length;i++)  
\{

for(int x = 0;x<arr[i].length;x++)
    	{   
            sum +=arr[i][x];
    	}
    }
       return sum;
    }