java--第六章：java语言基础5

绝地灬酷狼 2023-06-09 14:29 22阅读 0赞

### 1 方法 ###

**定义：**方法就是完成特定功能的代码块。函数在java中被称为方法。

**格式：**

修饰符 返回值类型  方法名 (参数类型 参数名1,参数类型 参数名2...)\{

方法体语句;

return 返回值;

修饰符：目前就用public static 后面再讲解其他的修饰符。

返回值类型：就是功能结果的数据类型。

方法名：符合命名规则即可，方便调用

参数：

实际参数：实际参与运算的

形式参数：方法定义上的，用于接收实际参数的

参数类型：参数的数据类型

参数名：变量名

方法体语句：完成功能的代码

return：结束代码的

返回值：功能的结果，由return带给调用者。

要想写好一个方法，就必须明确两个东西：

A：返回值类型，指结果的数据类型

B：参数列表，指要传递几个参数以及每个参数的数据类型

main方法是被虚拟机调用的，自己写的方法不调用不执行。

**有明确返回值的方法调用：**

A：单独调用，没有意义。

B：输出调用，有意义。但是不够好，因为不一定要把结果输出，我们可能针对结果采取进一步的操作。

C：赋值调用，推荐方式。

/*
        求两数据之和
        返回值类型：int
    	参数列表：2个，都是int类型
    */
    
    class FunDemo{
    	public static void main(String[] args){
    		int x=20;
    		int y=30;
    		
    		//调用1：单独调用
    		//sum(x,y);
    		
    		//调用2：输出调用
    		//System.out.println(sum(x,y));
    		
    		//调用3：赋值调用
    		int result=sum(x,y);
    		System.out.println(result);
    		
    	}
    	
    	//求两数据之和的方法
    	public static int sum(int a,int b){
    		int c = a+b;
    		return c;
    	}
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xlbW9udHJlZV9mdQ_size_16_color_FFFFFF_t_70][]

**练习1：返回两者中的较大值**

/*
      键盘录入两数据，返回两个数中的较大值
    */
    
    import java.util.Scanner;
    
    class FunTest{
    	public static void main(String[] args){
    		Scanner sc=new Scanner(System.in);
    		
    		System.out.println("请输入第一个数据");
    		int a=sc.nextInt();
    		
    		System.out.println("请输入第二个数据");
    		int b=sc.nextInt();
    		
    		int result = getMax(a,b);
    		System.out.println(result);
    	}
    	
    	public static int getMax(int a,int b){
    		//if语句
    		/*
    		if(a>b){
    			return a;
    		}else{
    			return b;
    		}
    		*/
    		
    		//三元语句
    		int c=((a>b)?a:b);
    		return c;
    	}
    }

**练习2：键盘录入两个数据，比较两个数是否相等**

/*
      键盘录入两个数据，比较两个数是否相等
    */
    
    import java.util.Scanner;
    
    class FunTest2{
    	public static void main(String[] args){
    	    Scanner sc=new Scanner(System.in);
    		
    		System.out.println("请输入第一个数据");
    		int a=sc.nextInt();
    		
    		System.out.println("请输入第二个数据");
    		int b=sc.nextInt();
    		
    		boolean flag=compare(a,b);
    		System.out.println(flag);
        }
    	
    	
    	public static boolean compare(int a,int b){
    		//if
    		/*
    		if(a==b){
    			return true;
    		}else{
    			return false;
    		}
    		*/
    		
    		//最简单的
    		return a == b;
    	}
    }

**练习3：键盘录入三个数据，返回三个数中的较大值**

/*
      键盘录入三个数据，返回三个数中的较大值
    */
    
    import java.util.Scanner;
    
    class FunTest3{
    	public static void main(String[] args){
    		Scanner sc=new Scanner(System.in);
    		
    		System.out.println("请输入第一个数据");
    		int a=sc.nextInt();
    		
    		System.out.println("请输入第二个数据");
    		int b=sc.nextInt();
    		
    		System.out.println("请输入第三个数据");
    		int c=sc.nextInt();
    		
    		int max=getMax(a,b,c);
    		System.out.println(max);
    	}
    	
    	public static int getMax(int a,int b,int c){
    		//if
    		/*
    		if(a>b){
    			if(a>c){
    				return a;
    			}else{
    				return c;
    			}
    		}else{
    			if(b>c){
    				return b;
    			}else{
    				return c;
    			}
    		}
    		*/
    		
    		//三元
    		return (a>b)? (a>c?a:c):(b>c?b:c);
    	}
    }

**方法的注意事项：**

1 方法不调用，不执行

2 方法与方法是平级关系，不能嵌套定义

3 方法定义的时候，参数之间用逗号隔开

4 方法调用的时候，不用再传递参数类型

5 如果方法有明确的返回值，一定要用return带回一个值

**返回值为void的调用，只能通过单独调用**

/*
      需求：在控制台输出如下的形状
      *****
      *****
      *****
      *****
    */
    
    class FunTest4{
    	public static void main(String[] args){
    		//for
    		for(int x=0;x<4;x++){
    			for(int y=0;y<5;y++){
    				System.out.print("*");
    			}
    			System.out.println();
    		}
    		
    		//要在控制台输出一个6行7列的星形图形
    		for(int x=0;x<6;x++){
    			for(int y=0;y<7;y++){
    				System.out.print("*");
    			}
    			System.out.println();
    		}
    		
    		//如果需要继续改变，我们就应该考虑使用方法改进
    		/*
    		   写什么样的方法呢？写一个m行n列的代码
    		   两个明确:
    		       返回值类型：这个时候没有明确的返回值，不写东西还不行，所以，这里是void
    			   参数列表：int m,int n
    		*/
    		
    		//单独调用
    		printxing(3,4);
    		
    		//输出调用,不可以
    		//System.out.println(printxing(3,4));
    		
    		//赋值调用,不可以
    		//void a=printxing(3,4);
    		//System.out.println(a);
    		
    	}
    	
    	public static void printxing(int m,int n){
    		for(int x=0;x<m;x++){
    			for(int y=0;y<n;y++){
    				System.out.print("*");
    			}
    			System.out.println();
    		}
    	}
    }

**练习4：键盘录入行数和列数，输出对应的星形**

/*
      键盘录入行数和列数，输出对应的星形
    */
    
    import java.util.Scanner;
    
    class FunTest5{
    	public static void main(String[] args){
    		Scanner sc=new Scanner(System.in);
    		
    		System.out.println("请输入行数");
    		int m=sc.nextInt();
    		
    		System.out.println("请输入列数");
    		int n=sc.nextInt();
    		
    		printxing(m,n);
    	}
    	
    	public static void printxing(int m,int n){
    		for(int x=0;x<m;x++){
    			for(int y=0;y<n;y++){
    				System.out.print("*");
    			}
    			System.out.println();
    		}
    	}
    	
    }

**练习5：键盘录入对应的乘法表**

/*
      键盘录入对应的乘法表
    */
    import java.util.Scanner;
    
    class FunTest6{
    	public static void main(String[] args){
    		Scanner sc=new Scanner(System.in);
    		
    		System.out.println("请输入n的值(1-9):");
    		int n=sc.nextInt();
    		
    		printNN(n);
    	}
    	
    	public static void printNN(int n){
    		for(int x=1;x<=n;x++){
    			for(int y=1;y<=x;y++){
    				System.out.print(y+"*"+x+"="+y*x+"\t");
    			}
    			System.out.println();
    		}
    	}
    }

**方法重载：**

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

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

class FunTest7{
    	public static void main(String[] args){
    		//jvm会根据不同的参数调用不同的功能
    		System.out.println(sum(1,2)); //3
    		System.out.println(sum(1,2,3)); //6
    		System.out.println(sum(1,2,3,4)); //10
    	}
    	
    	//需求1：求两个数的和
    	public static int sum(int a,int b){
    		return a+b;
    	}
    	
    	//需求2：求三个数的和
    	public static int sum(int a,int b,int c){
    		return a+b+c;
    	}
    	
    	//需求3：求四个数的和
    	public static int sum(int a,int b,int c,int d){
    		return a+b+c+d;
    	}
    }

方法重载的练习：比较两个数是否相等

/*
      比较两个数据是否相等。参数分别为：
      两个byte类型，两个short类型，两个int类型，两个long类型
      并在main方法中进行测试
    */
    
    class FunTest8{
    	public static void main(String[] args){
    		//测试
    		byte b1=3;
    		byte b2=4;
    		System.out.println("byte:"+compare(b1,b2));
    		
    		//测试
    		short s1=3;
    		short s2=4;
    		System.out.println("short:"+compare(s1,s2));
    	}
    	
    	//byte类型
    	public static boolean compare(byte a,byte b){
    		System.out.println("byte");
    		return a==b;
    	}
    	
    	//short类型
    	public static boolean compare(short a,short b){
    		System.out.println("short");
    		return a==b;
    	}
    	
    	//int类型
    	public static boolean compare(int a,int b){
    		System.out.println("int");
    		return a==b;
    	}
    	
    	//long类型
    	public static boolean compare(long a,long b){
    		System.out.println("long");
    		return a==b;
    	}
    }

### 2 数组 ###

**概念：**数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器。

数组既可以存储基本数据类型，也可以存储引用数据类型。

**定义格式：**1 数据类型\[\] 数组名---int\[\] a

2 数据类型 数组名\[\]---int a\[\]

**数组初始化：**java中的数组必须先初始化，才能使用。所谓的初始化，就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。

**数组初始化方式：**

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

2 静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度。int\[\] arr=new int\[\]\{1,2,3\};

**动态初始化：**

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

举例：int\[\] arr=new int\[3\] 定义了一个int类型的数组，这个数组中可以存放3个int类型的值

/*
      定义数组格式举例：
      1 int[] a;定义一个int类型的数组a变量
      2 int a[];定义一个int类型的a数组变量
      
      这两种定义效果是一样的，但是念法上有些小区别。推荐使用第一种。
    */
    
    class ArrDemo{
    	public static void main(String[] args){
    		//int[] a;
    		//可能尚未初始化变量a
    		//System.out.println(a);
    		
    		int[] arr=new int[3];
    		System.out.println(arr);//[I@15db9742 地址值
    		//要地址值没意义，想要数据值。数组中的每个元素都有编号，从0开始，最大的编号为数组的长度-1
    	    //用数组名和编号的配合就可以获取数组中的指定编号的元素，这个编号叫索引
    		//通过数组名访问数据的格式是：数组名[索引]；
    		
    		System.out.println(arr[0]);//0
    		System.out.println(arr[1]);//0
    		System.out.println(arr[2]);//0
    		
    	}
    }

**java中的内存分配：**

java程序在运行时，需要在内存中分配空间。为了提高运算效率，就对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。

分成了5块：

1栈 存储局部变量

2堆 存储new出来的东西

3方法区（后面讲）

4本地方法区（和系统相关）

5寄存器（和CPU相关）

局部变量：在方法定义中或者方法声明上的变量都称为局部变量。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xlbW9udHJlZV9mdQ_size_16_color_FFFFFF_t_70 1][]

**数组的内存图解：一个数组**

/*
      定义一个数组，输出该数组的名称和数组元素值。
      给该元素赋值，再次输出该数组的名称和数组元素值。
    */
    
    class ArrDemo1{
    	public static void main(String[] args){
    		int[] arr=new int[3];
    		
    		System.out.println(arr);
    		System.out.println(arr[0]);
    		System.out.println(arr[1]);
    		System.out.println(arr[2]);
    		
    		//给数组元素赋值
    		arr[0]=100;
    		arr[2]=200;
    		
    		System.out.println(arr);
    		System.out.println(arr[0]);
    		System.out.println(arr[1]);
    		System.out.println(arr[2]);
    	}
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xlbW9udHJlZV9mdQ_size_16_color_FFFFFF_t_70 2][]

**数组的内存图解：两个数组**

/*
      定义两个数组，输出两数组的名称和数组元素值。
      给两个元素赋值，再次输出该数组的名称和数组元素值。
    */
    
    class ArrDemo2{
    	public static void main(String[] args){
    		//第一个数组
    		int[] arr=new int[2];
    		//第二个数组
    		int[] arr2=new int[3];
    		
    		System.out.println(arr);
    		System.out.println(arr[0]);
    		System.out.println(arr[1]);
    		
    		System.out.println(arr2);
    		System.out.println(arr2[0]);
    		System.out.println(arr2[1]);
    		System.out.println(arr2[2]);
    		
    		arr[1]=20;
    		
    		arr2[1]=30;
    		arr2[0]=40;
    		
    		System.out.println(arr);
    		System.out.println(arr[0]);
    		System.out.println(arr[1]);
    		
    		System.out.println(arr2);
    		System.out.println(arr2[0]);
    		System.out.println(arr2[1]);
    		System.out.println(arr2[2]);
    	}
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xlbW9udHJlZV9mdQ_size_16_color_FFFFFF_t_70 3][]

**数组的内存图解：三个数组**

/*
      定义第一个数组，定义完毕后，给数组元素赋值，赋值完毕后，再输出数组名称和元素。
      定义第二个数组，定义完毕后，给数组元素赋值，赋值完毕后，再输出数组名称和元素。
      定义第三个数组，把第一个数组的地址值赋值给它。（注意类型一致）
      通过第三个数组的名称，去把元素重新赋值。最后，再次输出第一个数组的数组名称和元素。
    */
    
    class ArrDemo3{
    	public static void main(String[] args){
    		//定义第一个数组
    		int[] arr=new int[3];
    		arr[0]=88;
    		arr[1]=33;
    		arr[2]=66;
    		
    		System.out.println(arr);
    		System.out.println(arr[0]);
    		System.out.println(arr[1]);
    		System.out.println(arr[2]);
    		
    		//定义第二个数组
    		int[] arr2=new int[3];
    		arr2[0]=22;
    		arr2[1]=44;
    		arr2[2]=55;
    		
    		System.out.println(arr2);
    		System.out.println(arr2[0]);
    		System.out.println(arr2[1]);
    		System.out.println(arr2[2]);
    		
    		//定义第三个数组
    		int[] arr3=arr;
    		arr3[0]=100;
    		arr3[1]=100;
    		
    		System.out.println(arr);
    		System.out.println(arr[0]);//100
    		System.out.println(arr[1]);//100
    		System.out.println(arr[2]);//66
    	}
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xlbW9udHJlZV9mdQ_size_16_color_FFFFFF_t_70 4][]

**静态初始化：**

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

举例：int\[\] arr=new int\[\]\{1,2,3\};

简化格式：数据类型\[\] 数组名=\{元素1,元素2...\};

举例：int\[\] arr=\{1,2,3\};

注意：不要同时动态和静态进行。int\[\] arr=new int\[3\]\{1,2,3\};//错误

class ArrDemo4{
    	public static void main(String[] args){
    		//定义数组
    		int[] arr={1,2,3};
    		
    		System.out.println(arr);
    		System.out.println(arr[0]);
    		System.out.println(arr[1]);
    		System.out.println(arr[2]);
    	}
    }

**数组操作的两个小问题：越界和空指针**

class ArrDemo5{
    	public static void main(String[] args){
    		//定义数组
    		int[] arr={1,2,3};
    		
    		//ArrayIndexOutOfBoundsException:数组索引越界异常，原因为访问了不存在的索引
    		//System.out.println(arr[3]);
    		
    		//引用类型的常量：null空常量
    		//NullPointerException:空指针异常，原因为数组已经不再指向堆内存了,而还用数组名去访问元素
    		//arr=null;
    		//System.out.println(arr[0]);
    	}
    }

**数组操作1：遍历**

/*
      数组遍历：依次输出数组中的每一个元素
    */
    
    class ArrTest1{
    	public static void main(String[] args){
    		int[] arr={11,22,33,44,55};
    		int[] arr2={1,2,3,4,5,6,7,8,9};
    		
    		//获取每一个元素:结合索引可以找到数据
    		//System.out.println(arr[0]);
    		//System.out.println(arr[1]);
    		//System.out.println(arr[2]);
    		//System.out.println(arr[3]);
    		//System.out.println(arr[4]);
    		
    		//以上的做法可以，但是代码的重复度很高，输出语句和数组名都是相同，仅仅是索引变化
    		/*
    		for(int x=0;x<5;x++){
    			System.out.println(arr[x]);
    		}
    		*/
    		
    		//从0开始是明确的，但是为什么到5呢？因为是数的个数。
    		//很多时候，数组的元素不能靠数，数组给我们提供了一个属性：length
    		//格式：数组名.length
    		System.out.println(arr.length);
    		
    		for(int x=0;x<arr.length;x++){
    			System.out.println(arr[x]);
    		}
    		
    		printArr2(arr);
    		printArr2(arr2);
    		
    	}
    	
    	//如果想要对多个数组进行遍历，需要把每个代码都写一遍，所以可以用方法改进
    	public static void printArr(int[] arr){
    		for(int x=0;x<arr.length;x++){
    			System.out.println(arr[x]);
    		}
    	}
    	
    	//改进版本
    	public static void printArr2(int[] arr){
    		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：获取最值**

/*
      数组获取最值
      
      分析：先定义一个数组，并进行静态初始化；
            从数组中任意的找一个元素作为参照物（一般取第一个），默认它就是最大值
    		遍历其他元素，依次获取和参照物进行比对，如果大就留下来，小就离开
    		最后参照物里面保存的就是最大值
    */
    class ArrTest2{
    	public static void main(String[] args){
    		int[] arr={34,98,10,25,67};
    		/*
    		//获取数组中的最大值
    		int max=arr[0];
    		for(int x=1;x<arr.length;x++){
    			if(arr[x]>max){
    				max=arr[x];
    			}
    		}
    		System.out.println(max);
    		*/
    		int max=getMax(arr);
    		System.out.println(max);
    	}
    	
    	//封装成方法
    	public static int getMax(int[] arr){
    		//获取数组中的最大值
    		int max1=arr[0];
    		for(int x=1;x<arr.length;x++){
    			if(arr[x]>max1){
    				max1=arr[x];
    			}
    		}
    		return max1;
    	}
    }

**数组操作3：逆序**

/*
      数组元素逆序：把元素对调
      分析：把0索引和arr.length-1的数据交换
            把1索引和arr.length-2的数据交换
    		...
    		只要做到arr.length/2即可
    */
    class ArrTest3{
    	public static void main(String[] args){
    		int[] arr={12,98,50,34,76};
    		
    		//调用方法一
    		reverse(arr);
    		printArr(arr);
    		
    		//调用方法二
    		reverse2(arr);
    		printArr(arr);
    	}
    	
    	//方法一
    	public static void reverse(int[] arr){
    		//第一次交换
    		//int temp=arr[0];
    		//arr[0]=arr[arr.length-1];
    		//arr[arr.length-1]=temp;
    		//...
    		
    		//for改进
    		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 reverse2(int[] arr){
    		for(int start=0,end=arr.length-1;start<=end;start++,end--){
    			int temp=arr[start];
    			arr[start]=arr[end];
    			arr[end]=temp;
    		}
    	}
    	
    	//遍历数组用来打印
    	public static void printArr(int[] arr){
    		for(int x=0;x<arr.length;x++){
    			System.out.println(arr[x]);
    		}
    	}
    }

**数组操作4：查表法**

/*
       数组查表法：根据键盘录入的索引，查找对应的星期
    */
    import java.util.Scanner;
    
    class ArrTest4{
    	public static void main(String[] args){
    		//定义一个字符串数组
    		String[] strArray={"星期一","星期二","星期三","星期四","星期五","星期六","星期日"};
    		
    		Scanner sc=new Scanner(System.in);
    		int index=sc.nextInt();
    		
    		System.out.println("你要查找的日期是:"+strArray[index]);
    	}
    }

**数组操作5：基本查找**

/*
      数组元素查找：查找指定元素第一次在数组中出现的索引
      分析：
           遍历数组，依次获取数组中的每个元素，和已知的数据进行比较
    	   如果相等，就返回当前的索引值
    */
    
    class ArrTest5{
    	public static void main(String[] args){
    		int[] arr={200,250,38,888,666,444};
    		
    		int index=getIndex(arr,250);
    		System.out.println(index);
    	}
    	
    	//查找250第一次出现的索引
    	//如果找不到数据，一般返回一个负数：-1
    	public static int getIndex(int[] arr,int value){
    		for(int x=0;x<arr.length;x++){
    			if(arr[x]==value){
    				return x;
    			}
    		}
    		
    		return -1;
    	}
    	
    	//方法2
    	public static int getIndex2(int[] arr,int value){
    		int index=-1;
    		
    		for(int x=0;x<arr.length;x++){
    			if(arr[x]==value){
    				index=x;
    				break;
    			}
    		}
    		
    		return index;
    	}
    }

### 3 二维数组 ###

**概述：**一个元素为一维数组的数组

**格式1：(动态初始化)**

数据类型\[\]\[\] 变量名=new 数据类型\[m\]\[n\]

m表示这个数组有多少个一维数组

n表示每一个一维数组的元素个数

举例：int\[\]\[\] arr=new int\[3\]\[2\] 这个二维数组有3个一维数组，名称是arr\[0\],arr\[1\],arr\[2\]。每个一维数组有两个元素。

注意：

1数据类型  变量名\[\]\[\]=new 数据类型\[m\]\[n\]也可以表示为二维数组

2数据类型\[\]  变量名\[\]=new 数据类型\[m\]\[n\]也可以表示为二维数组

3int\[\] x,y\[\] 这里x为一维数组，y为二维数组

class Arr2Demo{
    	public static void main(String[] args){
    		//定义一个二维数组
    		int[][] arr=new int[3][2];
    		
    		//输出二维数组的名称
    		System.out.println(arr);//地址值[[I@15db9742
    		//输出二维数组的第一个元素一维数组的名称
    		System.out.println(arr[0]);//地址值[I@6d06d69c
    		//输出二维数组的元素
    		System.out.println(arr[0][0]);//0
    		System.out.println(arr[0][1]);//0
    	}
    }

**格式2：(动态初始化)**

数据类型\[\]\[\] 变量名=new 数据类型\[m\]\[\]

m表示这个二维数组有多少个一维数组

这一次没有直接给出一维数组的元素个数，可以动态的给出。

举例：

int\[\]\[\] arr=new int\[3\]\[\]

arr\[0\]=new int\[2\]第一个一维数组有2个元素

arr\[1\]=new int\[3\]第一个一维数组有3个元素

arr\[2\]=new int\[1\]第一个一维数组有1个元素

/*格式2*/
    class Arr2Demo1{
    	public static void main(String[] args){
    		//定义一个二维数组
    		int[][] arr=new int[3][];
    		
    		System.out.println(arr);     //[[I@15db9742
    		System.out.println(arr[0]);  //null
    		System.out.println(arr[1]);  //null
    		System.out.println(arr[2]);  //null
    		
    		//动态的为每个一维数组分配空间
    		arr[0]=new int[2];
    		arr[1]=new int[3];
    		arr[2]=new int[1];
    		
    		System.out.println(arr[0]);  //[I@6d06d69c
    		System.out.println(arr[1]);  //[I@7852e922
    		System.out.println(arr[2]);  //[I@4e25154f
    		
    		System.out.println(arr[0][0]);  //0
    		System.out.println(arr[0][1]);  //0
    		//System.out.println(arr[0][2]);  //ArrayIndexOutOfBoundsException
    		
    		arr[1][0]=100;
    		arr[1][1]=200;
    		System.out.println(arr[1][0]);  //100
    		System.out.println(arr[1][1]);  //200
    	}
    }

**格式3：(静态初始化)**

数据类型\[\]\[\] 变量名=new 数据类型\[\]\[\]\{ \{元素...\},\{元素...\},\{元素...\}\}

简化版格式：

数据类型\[\]\[\] 变量名=\{ \{元素...\},\{元素...\},\{元素...\}\}

举例：

int\[\]\[\] arr=\{ \{1,2,3\},\{4,5\},\{6\}\}

/*格式三*/
    class Arr2Demo2{
    	public static void main(String[] args){
    		int[][] arr={
       {1,2,3},{4,5},{6}};
    		
    		System.out.println(arr);
    		
    		System.out.println(arr[0]);
    		System.out.println(arr[1]);
    		System.out.println(arr[2]);
    		
    		System.out.println(arr[0][0]);  //1
    		System.out.println(arr[1][0]);  //4
    		System.out.println(arr[2][0]);  //6
    		
    		System.out.println(arr[0][1]);  //2
    		System.out.println(arr[1][1]);  //5
    		System.out.println(arr[2][1]);  //报错
    	}
    }

**练习1：遍历，打印杨辉三角**

/*
      公司年销售额遍历
      某公司按照季度和月份统计的数据如下：单位(万元)
      第一季度：22,66,44
      第二季度：77,33,88
      第三季度：25,45,65
      第四季度：11,66,99
      
      打印杨辉三角(行数可以键盘录入)
      
      外循环控制的是二维数组的长度，内循环控制的是一维数组的长度
    */
    class Arr2Test1{
    	public static void main(String[] args){
    		//定义一个二维数组
    		int[][] arr={
       {1,2,3},{4,5,6},{7,8,9}};
    		int[][] arr2={
       {22,66,44},{77,33,88},{25,45,65},{11,66,99}};
    		
    		/*
    		for(int x=0;x<arr[0].length;x++){
    			System.out.println(arr[0][x]);
    		}
    		*/
    		
    		//用循环写
    		/*
    		for(int x=0;x<arr.length;x++){
    			for(int y=0;y<arr[x].length;y++){
    				System.out.print(arr[x][y]+" ");
    			}
    			System.out.println();
    		}
    		*/
    		
    		//调用方法
    		printArr(arr);
    		printArr(arr2);
    	}
    	
    	
    	//用方法改进
    	public static void printArr(int[][] arr){
    		for(int x=0;x<arr.length;x++){
    			for(int y=0;y<arr[x].length;y++){
    				System.out.print(arr[x][y]+" ");
    			}
    			System.out.println();
    		}
    	}
    }

**练习2：求和**

/*
      公司年销售额求和
      某公司按照季度和月份统计的数据如下：单位(万元)
      第一季度：22,66,44
      第二季度：77,33,88
      第三季度：25,45,65
      第四季度：11,66,99
      
      打印杨辉三角(行数可以键盘录入)
    */
    class Arr2Test2{
    	public static void main(String[] args){
    		//定义数组
    		int[][] arr={
       {22,66,44},{77,33,88},{25,45,65},{11,66,99}};
    		//定义变量
    		int sum=0;
    		
    		//通过遍历获得每个元素
    		for(int x=0;x<arr.length;x++){
    			for(int y=0;y<arr[x].length;y++){
    				sum += arr[x][y];
    			}
    		}
    		System.out.println(sum);
    		
    	}
    	
    }

**练习3：打印杨辉三角**

/*
      需求：打印杨辉三角(行数可以键盘录入)
      
      1
      1 1
      1 2 1
      1 3 3 1
      1 4 6 4 1
      1 5 10 10 5 1
      
      规律：
      1 任何一行的第一列和最后一列都是1
      2 从第三行开始，每一个数据是它上一行的前一列和它上一行的本列之和
      
      步骤：
      1 首先定义一个二维数组。行数如果是n，那列数也先定义为n。这个n来自于键盘录入。
      2 给这个二维数组任何一行的第一列和最后一列赋值为1
      3 按照规律给其他元素赋值
        从第三行开始，每一个数据是它上一行的前一列和它上一行的本列之和
      4 遍历这个二维数组
    
    */
    import java.util.Scanner;
    class Arr2Test3{
    	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];
    		
    		//给这个二维数组任何一行的第一列和最后一列赋值为1
    		for(int x=0;x<arr.length;x++){
    			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];
    			}
    		}
    		
    		
    		
    		//遍历二维数组
    		for(int x=0;x<arr.length;x++){
    			for(int y=0;y<=x;y++){
    				System.out.print(arr[x][y]+"\t");
    			}
    			System.out.println();
    		}
    		
    	}
    }

**思考题1：参数传递问题**

/*
        看一下代码，分析参数传递规律
          基本数据类型：形式参数的改变对实际参数没有影响
    	  引用数据类型：形式参数的改变直接影响实际参数
    */
    class Arr2Test4{
    	public static void main(String[] args){
    		int a=10;
    		int b=20;
    		System.out.println(a);//10
                    System.out.println(b);//20
    		change(a,b);
    		System.out.println(a); //?10
    		System.out.println(b); //?20
    		
    		int[] arr={1,2,3,4,5};
    		change(arr);
    		System.out.println(arr[1]); //?4
    	}
    	
    	public static void change(int a,int b){
    		System.out.println(a); //10
    		System.out.println(b); //20
    		a=b;
    		b=a+b;
    		System.out.println(a); //20
    		System.out.println(b); //40
    	}
    	
    	public static void change(int[] arr){
    		for(int x=0;x<arr.length;x++){
    			if(arr[x]%2==0){
    				arr[x]*=2;  //arr={1,4,3,8,5};
    			}
    		}
    	}
    }

**思考题2：加密问题**

/*
       某个公司采用公用电话传递数据信息，数据是小于8位的整数，为了确保安全，
       在传递过程中需要加密，加密规则如下：
            首先将数据倒序，然后将每位数字都加上5，再用和除以10的余数代替该数字，
    		最后将第一位和最后一位数字交换，请任意给定一个小于8位的整数，
    		然后，把加密后的结果在控制台打印出来。
    		
       题目要求：
           1 小于8位的整数 int number=123456
    	   2 加密规则
    	     a 将数据倒序 654321
    		 b 然后将每位数字都加上5，再用和除以10的余数代替该数字 109876
    		 c 最后将第一位和最后一位数字交换 609871
    		 d 加密后的结果在控制台打印出来 609871
        
    	*把数据变成数组就好做了*
    	
    	如何把数据转成数组呢？
    	    1 定义一个数据
    		  int number=123456;
    		2 定义一个数组，但是数组的长度是多少呢？
    		  int[] arr=new int[8];
    		  在赋值的时候，用一个变量记录索引的变化。
    		  定义一个索引值是0
    		  int index = 0;
    		3 获取每个数据
    		  int ge=number%10;
    		  int shi=number/10%10;
    		  int bai=number/100%10;
    		  
    		  arr[index]=ge;
    		  index++;
    		  arr[index]=shi;
    		  index++;
    		  arr[index]=bai;
    		    
    */
    class Arr2Test5{
    	public static void main(String[] args){
    		//定义数据
    		int number=123456;
    		//定义数组
    		int[] arr=new int[8];
    		
    		/*
    		int index=0;
    		arr[index]=number%10;
    	    index++;
    		arr[index]=number/10%10;
    		index++;
    		arr[index]=number/10/10%10;
    		*/
    		
    		//将数据倒序
    		int index=0;
    		while(number>0) {
    			arr[index]=number%10;
    			index++;
    			number/=10;
    		}
    		
    		//然后将每位数字都加上5，再用和除以10的余数代替该数字
    		for(int x=0;x<index;x++){
    			arr[x]+=5;
    			arr[x]%=10;
    		}
    		
    		//最后将第一位和最后一位数字交换
    		int temp=arr[0];
    		arr[0]=arr[index-1];
    		arr[index-1]=temp;
    		
    		//输出数据
    		for(int x=0;x<index;x++){
    			System.out.print(arr[x]);
    		}
    		System.out.println();
    	}
    }

**加密问题的代码改进**

/*
      改进：
          1 数据改为键盘录入
    	  2 代码改为方法实现
    */
    import java.util.Scanner;
    
    class Arr2Test6{
    	public static void main(String[] args){
    		Scanner sc=new Scanner(System.in);
    		
    		System.out.println("请输入一个数据(小于8位):");
    		int number=sc.nextInt();
    		
    		//写功能把number进行加密
    		String result=jiami(number);
    		System.out.println("加密后的结果是:"+result);
    	}
    	
    	//把数据实现加密
    	public static String jiami(int number){
    		int[] arr=new int[8];
    		int index=0;
    		
    		while(number>0){
    			arr[index]=number%10;
    			index++;
    			number/=10;
    		}
    		
    		for(int x=0;x<index;x++){
    			arr[x] += 5;
    			arr[x] %= 10;
    		}
    		
    		int temp=arr[0];
    		arr[0]=arr[index-1];
    		arr[index-1]=temp;
    		
    		String s="";
    		for(int x=0;x<index;x++){
    			s += arr[x];
    		}
    		return s;
    	}
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xlbW9udHJlZV9mdQ_size_16_color_FFFFFF_t_70]: /images/20230531/2362b42c4414464bb910057a467f87d8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xlbW9udHJlZV9mdQ_size_16_color_FFFFFF_t_70 1]: /images/20230531/739aa015c5db4f49ac70917c5fbecbf5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xlbW9udHJlZV9mdQ_size_16_color_FFFFFF_t_70 2]: /images/20230531/41e028526e6545e8add16621fbffc0ef.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xlbW9udHJlZV9mdQ_size_16_color_FFFFFF_t_70 3]: /images/20230531/2bbd041d803747c5ae5fecb9881f4bb7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xlbW9udHJlZV9mdQ_size_16_color_FFFFFF_t_70 4]: /images/20230531/128bdf88b42240909ef432d8119dc307.png