java 入门 day06

1、二维数组
/**
* 二维数组：数组中的数组
* 1、怎么声明二维数组?
* 数组类型[][] 数组名;
* 第一个中括号代表:这个二维数组包含几个一维数组
* 第二个中括号代表：每个一维数组中有多少元素
*
* 2、初始化二维数组
* 第一种：动态初始化
* 第二种:静态初始化

		//1、创建一个二维数组，并动态初始化
		
		/**
		 * 5代表5行或者表示5个一维数组
		 * 7代表7列或者每一个一维数组的长度为7
		 */
		int[][] array=new int[5][7];
		
		//2、如何赋值？
		array[0][0]=10;//第一个一维数组的第一个元素值为10
		array[3][6]=5;//第四个一维数组的第七个元素的值为5
		System.out.println(array[0][0]);//10
		System.out.println(array[3][0]);//0（因为有默认值）
		
		//3、静态初始化
		int [][]array1=new int[][] {{1,2},{2,3,4},{5,9,89,1}};
		System.out.println(array1[2][2]);//89
		
		//简写
		int[][] array2= {{1,2},{2,3,4},{5,9,89,1}};
		

	//4、遍历二维数组
		System.out.println("使用for循环=========");
		//外层循环控制行(每个一维数组)
		for(int i=0;i<array2.length;i++) {
			//内层循环控制列
			for(int j=0;j<array2[i].length;j++) {
				System.out.print(array2[i][j]+" ");
			}
			System.out.println();
		}
		
		System.out.println("使用增强for循环==========");
		for(int []i:array2) {
			for(int m:i) {
				System.out.print(m+" ");
			}
			System.out.println();
		}

参考其他题目：

/**
* 在一个酒店中，一共有三层楼，每层有四个房间。
* 101 102 103
* 201 202 203 205
* 301 302
* 楼层：使用数字1，2，3表示
* 房间号：使用101，102，103，104，表示…
* 要求：使用二维数组赋值并遍历输出
*
*/

		//创建一个二维数组,并对其进行静态初始化
		int [][] arr=new int[][] {{101,102,103},{201,202,203,205},{301,302}};

		//遍历
		
		System.out.println("使用for循环============");
		for(int i=0;i<arr.length;i++) {
			System.out.println("这里是楼层"+(i+1));
			System.out.println("该楼层的房间号为：");
			for(int j=0;j<arr[i].length;j++) {
				System.out.print(arr[i][j]+" ");
			}
			System.out.println();
		}
		
		System.out.println("使用for循环增强版=============");
		for(int []i:arr) {//返回数组
			System.out.println("楼层号为");
			for(int m:i) {
				System.out.print(m+" ");
			}
			System.out.println();
		}

2、方法
/**
* 1、什么是方法？
* 方法就是把一堆需要重复执行的业务逻辑代码封装起来，
* 如果程序需要使用这段代码的时候，我们直接调用方法即可。
*
* 好处：提高代码的可重用性、维护性好、可读性好
*
* 可以把一个方法比喻成榨汁机
* 材料：水果
* 产出物：果汁
*
* 映射到java程序中
* 材料（参数）：进入方法的数据
* 产出物（返回值）:方法根据参数处理后的结果
*
* 2、怎么定义一个方法？
* 访问修饰符 [static]方法的返回值类型 方法名(形参列表){
* 逻辑代码块;
* return 返回值;
* }
*
* (1)、访问修饰符（权限修饰符）
* public ：公共的，在当前项目下的任何地方都可以访问
* private:私有的，只能在当前类下访问
* protected:受保护的，在同一个包或者其他派生类中可以访问
* default:缺省，只能在当前包下面进行访问
*
* (2)、方法的返回值类型：方法执行完成以后最终产生的结果是什么类型的
* (3)、方法名:
* 自己定义的名字，首字母小写，采用驼峰式命名法
* (4)、形参列表：由多个参数组成的列表
* 形参:用于接收调用这实际传来的数据
* (5)、return
* 作用：把方法最终处理的结果返回给调用者；
* 结束当前方法；
* 注意：返回的数据类型和方法的返回值类型一致
*
*
*
*/
1、有返回值类型的方法

	//计算a+b的和
	public static int sum(int a,int b) {
		return a+b;
	}
	

2、无返回值类型的方法
/**
* 无返回值方法:
* 方法执行一些操作，没有把执行结果返回给调用者，只是执行了
* 方法体。
*
* 访问修饰符 [static] void 方法名(形参列表){
* 方法体;
* }
*/

	//打印10遍好好学习
	public static void StudyHard() {
		for(int i=1;i<=10;i++) {
			System.out.println("好好学习"+i);
		}

3、参数传递

/**

• 参数传递:调用者在调用方法的时候，向方法内传入数据的一系列动作
• 形参：在定义方法的时候，写在小括号里面的参数，作用是：接收调用者传递数据
• 实参：在调用方法的时候、真正传递到方法的数据

*参数传递：有两种类型
*基本数据类型（以及String ）:形参的操作不会影响实际的参数
*引用数据类型：形参的操作会影响实参的参数
*
*/
1、基本数据类型传递

	public static void main(String[] args) {
		int a=10;
		int b=10;
		System.out.println("a="+a);//10
		System.out.println("b="+b);//10
		
		//调用方法
		change(a,b);
		
		System.out.println("a="+a);//10
		System.out.println("b="+b);//10

	}
	//定义一个方法，把形参扩大10倍
	public static void change(int a,int b) {
		a*=10;
		b*=10;
		System.out.println("a="+a);//100
		System.out.println("b="+b);//100
	}

2、引用数据类型传递

		public static void main(String[] args) {

		int [] arr= {10,20};
		System.out.println(arr[0]);//10
		System.out.println(arr[1]);//20
		
		change(arr);
		
		System.out.println(arr[0]);//100
		System.out.println(arr[1]);//200

	}
	public static void change(int []arr) {
		arr[0]*=10;
		arr[1]*=10;
		System.out.println(arr[0]);//100
		System.out.println(arr[1]);//200
	}

4、重载

对于类似累加的操作，因为形参列表的不同，所以定义多个方法名
弊端：
1、麻烦
2、代表调用者需要记住多个方法名，而且容易记错，
那么可不可以把这些类似操作起一个相同的方法名呢？
可以，使用方法重载

什么是方法重载？
方法名必须相同，参数列表必须不同
参数列表必须不同,体现在:

• (1).参数列表个数的不同
• (2).参数列表的类型的不同
• (3).参数列表类型的顺序不同

注意:方法重载和方法的返回值类型无关，和参数名也没有任何关系。

	//计算a+b的和
	public static int sum(int a,int b) {
	//之所以这里加上static是因为我要在main方法中去调用方法，而静态方法只能调用静态变量或静态方法
		return a+b;
	}
	
	//计算a+b+c的和
	public static int sum(int a,int b,int c) {
		return a+b+c;
	}
	
	public static double sum(int a,double b) {
		return a+b;
	}
	public static double sum(double a,int b) {
		return a+b;
	}

!这里插入图片描述](https://img-blog.csdnimg.cn/20200807174943499.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3F1YW5zaXdlbjUzMDc=,size_16,color_FFFFFF,t_70)

参考其他题目:

与void add(int a,char b,double c){}构成重载：

void add(int x,char y,double z){}   //不是，方法重载与参数名无关

int add(int a,double c,char b){}  //是，参数列表的数据类型的顺序不同

void add(int a,double c,char b){}  //是，参数列表的数据类型的顺序不同

boolean add(int c,char b){}  //是，参数列表的个数不同

void add(double c){}   //是，参数列表的个数不同

double add(int x,char y,double z){}  //不是，与参数名无关

void adds(double c){}  //不是，方法名不相同

String add(int a,double b,double c){}  //是，与参数列表的类型不同
String add(int a ,char b, double c){}  //不是，与方法的返回值类型无关