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

1 方法

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

格式：

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

      方法体语句;

      return 返回值;

}

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

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

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

参数：

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

扫描二维码关注公众号，回复： 8496058 查看本文章

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

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

参数名：变量名

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

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;
	}
}

练习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相关）

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

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

/*
  定义一个数组，输出该数组的名称和数组元素值。
  给该元素赋值，再次输出该数组的名称和数组元素值。
*/

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]);
	}
}

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

/*
  定义两个数组，输出两数组的名称和数组元素值。
  给两个元素赋值，再次输出该数组的名称和数组元素值。
*/

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]);
	}
}

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

/*
  定义第一个数组，定义完毕后，给数组元素赋值，赋值完毕后，再输出数组名称和元素。
  定义第二个数组，定义完毕后，给数组元素赋值，赋值完毕后，再输出数组名称和元素。
  定义第三个数组，把第一个数组的地址值赋值给它。（注意类型一致）
  通过第三个数组的名称，去把元素重新赋值。最后，再次输出第一个数组的数组名称和元素。
*/

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
	}
}

静态初始化：

格式：数据类型[] 数组名=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;
	}
}