Java方法及其一维数组

一、静态方法

1.概念

特定功能的代码块

2.好处

减少了代码的冗余

3.注意

1.方法编写的位置：类里
2.方法与方法之间是平级关系（不能在一个方法中声明另一个方法）
3.方法不被调用，永远就是个摆设

4.方法的语法结构分类

1.无返回值无参数的方法
语法结构：
访问修饰符 static void 方法名(){
…代码块…
}

需求：编写方法(printStar)，打印三角形
2.有参数的方法

3.有返回值的方法

	public static void main(String[] args){
		//调用静态方法：当前方法(main)和调用该方法(run、play)在同一个类中的调用方式
		//run();
		//run();
		//play();
		//run();
		//play();
		//run();
		
		//调用静态方法：当前方法(main)和调用该方法(run、play)不在同一个类中的调用方式
		Test01.run();
		Test01.run();
		Test01.play();
		Test01.run();
		Test01.play();
		Test01.run();
		
		printStar();
		printStar();
		printStar();
	}
	
	public static void printStar(){
		for(int i = 0;i<5;i++){
			for(int j = 0;j<=i;j++){
				System.out.print("*");
			}
			System.out.println();
		}
	}
	
	public static void run(){
		System.out.println("风骚的走位...");
	}
	
	public static void play(){
		System.out.println("发技能...");
	}
	
}

5.方法的分类

静态方法、成员方法、构造方法

  	1.无返回值无参数的方法
  		语法结构：
  			访问修饰符 static void 方法名(){
  				...代码块...
  			}
  			
  		需求：编写方法(printStar)，打印三角形
  		
  	2.有参数的方法
  		语法结构：
  			访问修饰符 static void 方法名(参数类型 变量名){
  				...代码块...
  			}
  		注意：
  			1.形参：形式参数，方法声明时，规定调用时要传入的数据类型及接收数据的变量
  			2.实参：实际参数，调用方法时传入的具体数据
  			3.实参与形参类型必须兼容
  			4.多个参数用逗号分隔
  	
  		需求1：编写方法(printStar01)，打印三角形，打印行数由调用方指定
  		需求2：编写方法(printStar02)，打印三角形，打印行数及内容由调用方指定

	public static void main(String[] args){
		//调用方
		printStar01(3);
		printStar01(5);
		printStar01('A');//传入ASCII
		
		printStar02(3,"$");
		printStar02(5,"#");
	}
	
	public static void printStar02(int num,String str){
		for(int i = 0;i<num;i++){
			for(int j = 0;j<=i;j++){
				System.out.print(str);
			}
			System.out.println();
		}
	}
	
	public static void printStar01(int num){
		for(int i = 0;i<num;i++){
			for(int j = 0;j<=i;j++){
				System.out.print("*");
			}
			System.out.println();
		}
	}
}

6.有返回值的方法

语法结构：
public static 返回值类型 方法名([参数]){
…代码块…
return 返回数据;
}

  		注意：	
  			1.方法功能单一性
  			2.return下面不能接执行语句，因为return表示结束当前方法
  			3.声明方法时规定返回值类型
  			4.return后面接的是要返回的具体数据
  			5.声明方法时规定的返回值类型必修和return后的数据类型兼容
  			6.方法A中有a和b的变量，方法B中也a和b的变量，这几个变量不互相冲突，因为方法中的变量叫做局部变量，作用域在该方法内
  		
  		需求1：编写方法(add),传入两个int值，求和
  		需求2：编写方法(getMax),传入两个int值，比较最大值

7.总结 - 方法的使用

不需要外界传入参数和不需要返回给外界数据，就使用无参数无返回值的方法
需要外界传入参数，就使用带参数的方法
需要返回给外界数据，就使用带返回值的方法
经验：声明一个方法
1.考虑方法名
2.考虑是否需要参数（传入数据）
3.考虑是否需要返回数据（向外界传出数据）

	public static void main(String[] args){
		
		int sum = add(10,20);
		sum = add(sum,30);
		System.out.println(sum);//60
		
		int result = getMax(666,888);
		System.out.println(result);
	}
	
	public static int getMax(int a,int b){
		int max = (a>b)?a:b;
		return max;
	}
	
	
	//方法声明时规定返回值类型
	public static int add(int a,int b){
		int result = a+b;
		return result;//返回具体参数
	}

}

二、方法的重载

1.含义

方法与方法之间的关系

2.好处

系统会根据实参类型自动匹配到对应方法

3.条件

  	1.在同一个类里
  	2.方法名一致
  	3.参数列表的个数或者类型不一致
  	4.与返回值无关

4.应用场景

在同一个类里，有多个方法功能一致，细节实现不一样，就可以考虑使用重载

5.需求

​ 需求：编写一个方法，求两个int之和
​ 需求：编写一个方法，求三个int之和
​ 需求：编写一个方法，求两个double之和
​ 需求：编写一个方法，求三个double之和

​ 需求：编写一个方法，求两个int最大值
​ 需求：编写一个方法，求三个int最大值
​ 需求：编写一个方法，求四个int最大值

	public static void main(String[] args){
		
		System.out.println(add(10,20));
		
		System.out.println(getMax(10,20,30,40));
	}
	
	public static int getMax(int a,int b){
		return (a>b)?a:b;
	}
	
	public static int getMax(int a,int b,int c){
		int max = getMax(a,b);
		max = getMax(max,c);
		return max;
	}
	
	public static int getMax(int a,int b,int c,int d){
		int max = getMax(a,b);
		max = getMax(max,c);
		max = getMax(max,d);
		return max;
	}

	
	public static int add(int a,int b){
		return a+b;
	}
	
	public static int add(int a,int b,int c){
		return a+b+c;
	}
	
	public static double add(double a,double b){
		return a+b;
	}
	
	public static double add(double a,double b,double c){
		return a+b+c;
	}
}

三、递归

1.概念

方法调用方法自身

	public static void main(String[] args){
		
		/**
			错误示范：方法死循环的调用方法自身
			该代码会导致栈内存溢出的错误
			原因：调用方法，就会在栈内存中开辟空间，用于存放该方法的局部变量，
				  死循环的调用方法，栈内存就会满载并溢出
		*/
		method();
	}
	
	public static void method(){
		
		method();
	}

}

2.注意

​ 1.找规律
​ 2.找出口

3.需求

编写一个方法，传入n，求n的阶乘

​ 阶乘：数学中的概念
​ 5! = 12345 --> 5! = 4!5
​ 4! = 1234 --> 4! = 3!4
​ 3! = 12*3 --> 3! = 2!3
​ 2! = 12 --> 2! = 1!*2
​ 1! = 1 --> 1! = 1 找出口
​ --> n! = (n-1)! * n 找规律

	public static void main(String[] args){
		
		int num = method(5);
		System.out.println(num);
	}
	
	public static int method(int n){
		if(n != 1){
			return method(n-1)*n;
		}else{
			return 1;
		}
	}
}

有一对兔子，从出生后第3个月起每个月都生对兔子，
小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，
问n月的兔子总数为多少？

找规律：当月兔子个数 = 上月兔子个数+上上月兔子个数
找出口：第一个月和第二个月兔子都是1对

	public static void main(String[] args){
		
		System.out.println(getRabbit(9));
	}
	
	public static int getRabbit(int month){
		if(month==1 || month==2){
			return 1;
		}else{
			return getRabbit(month-1) + getRabbit(month-2);
		}
	}
	
}

四·、方法版万年历

	public static void main(String[] args){
		Scanner scan = new Scanner(System.in);
		System.out.println("请输入年："); //2021
		int year = scan.nextInt();
		System.out.println("请输入月："); //7
		int month = scan.nextInt();
		
		//1.计算1900~输入年的总天数
		int allDayOfYear = getAllDayOfYear(1900,year);
		
		//2.计算1~输入月的总天数
		int allDayOfMonth = getAllDayOfMonth(year,1,month);

		//3.年的总天数 + 月的总天数
		int allDay = allDayOfYear + allDayOfMonth + 1;
		
		//4.获取星期
		int week = getWeek(allDay);
		
		//5.获取当月天数
		int day = getDay(year,month);
		
		//5.打印日期
		printCalendar(year,month,day,week);
	}
	
	//打印日期
	public static void printCalendar(int year,int month,int day,int week){
		System.out.println(" --- " + year + "年 - " + month + "月 ---");
		System.out.println("一\t二\t三\t四\t五\t六\t日");

		int num = 0;
		for(int i = 1;i<week;i++){
			System.out.print("\t");
			num++;
		}
		
		for(int i = 1;i<=day;i++){
			System.out.print(i + "\t");
			num++;
			if(num%7==0){
				System.out.println();
			}
		}
	}
	
	//获取星期
	public static int getWeek(int allDay){
		if(allDay%7 == 0){
			return 7;
		}
		return allDay%7;
	}
	
	//获取开始月到结束月的天数
	public static int getAllDayOfMonth(int year,int startMonth,int endMonth){
		int allDayOfMonth = 0;
		for(int i = startMonth;i<endMonth;i++){
			allDayOfMonth += getDay(year,i);
		}
		return allDayOfMonth;
	}
	
	//获取当月天数
	public static int getDay(int year,int month){
		int day = 0;
		switch(month){
			case 1:case 3:case 5:case 7:case 8:case 10:case 12:
				day=31;
			break;
			case 4:case 6:case 9:case 11:
				day=30;
			break;
			case 2:
				if(isLeapYear(year)){
					day=29;
				}else{
					day=28;
				}
			break;
		}
		return day;
	}
	
	//获取开始年到结束年的天数
	public static int getAllDayOfYear(int startYear,int endYear){
		int allDayOfYear = 0;
		for(int i = startYear;i<endYear;i++){
			if(isLeapYear(i)){
				allDayOfYear+=366;
			}else{
				allDayOfYear+=365;
			}
		}
		return allDayOfYear;
	}
	
	//判断是否是闰年
	public static boolean isLeapYear(int year){
		if(year%4==0&&year%100!=0 || year%400== 0){
			return true;
		}
		return false;
	}
	
	
}

五、一维数组

1.概念

一组数据的容器（数组可以存放多个数据）

2.注意

​ 1.数组是引用数据类型
​ 2.数组中的数据又叫做元素
​ 3.每个元素都有编号叫做下标/索引
​ 4.下标从0开始
​ 5.数组初始化后，会在内存中开辟一连串连续的空间
​ 6.数组一旦初始化后长度不可以改变（数组没有扩容和删除）
​ 7.数组的操作：添加、修改、查询

3.数组的声明

数据类型[] 数组名;

4.数组的初始化

静态初始化：数据由程序员指定，长度由系统分配

动态初始化：长度由程序员指定，数据由系统分配(默认值)
整数类型：0
浮点类型：0.0
字符类型：’ ’
布尔类型：false
引用类型：null(空)

	public static void main(String[] args){
		
		//静态初始化1
		//String[] names = new String[]{"椎名空","爱田奈奈","水野朝阳","桃谷绘里香","铃原爱蜜莉"};
		
		//静态初始化2
		//String[] names;
		//names = new String[]{"椎名空","爱田奈奈","水野朝阳","桃谷绘里香","铃原爱蜜莉"};
		
		//静态初始化3
		String[] names = {"椎名空","爱田奈奈","水野朝阳","桃谷绘里香","铃原爱蜜莉"};
		
		//设置指定下标上的元素
		names[3] = "林成";
		
		//获取指定下标上的元素
		String n = names[3];
		System.out.println("获取指定下标上的元素：" + n);//林成
		
		//ArrayIndexOutOfBoundsException - 数组下标越界异常
		//System.out.println(names[100]);
		
		//获取元素个数
		int len = names.length;
		System.out.println("获取元素个数：" + len);//5
		
		System.out.println("-----------");
		
		//遍历 - for循环
		for(int i = 0;i<names.length;i++){
			System.out.println(names[i]);
		}
		
		System.out.println("-----------");
		
		//遍历 - foreach(增强for循环)
		for(String str:names){//遍历数组，依次把元素赋值给str
			System.out.println(str);
		}
		
		/**
			遍历时要使用到下标，就用for循环遍历
			遍历时要不使用到下标，就用foreach遍历	
		*/
	}
}

5.静态初始化 vs 动态初始化

​ 一开始就知道数据：静态初始化
​ 一开始就知道长度：动态初始化

	public static void main(String[] args){
		
		//动态初始化1
		String[] names = new String[5];//5->5个长度
		
		//设置指定下标上的元素
		names[0] = "林成a";
		names[1] = "林成b";
		names[2] = "林成c";
		names[3] = "林成d";
		names[4] = "林成e";
		
		//获取指定下标上的元素
		String n = names[3];
		System.out.println("获取指定下标上的元素：" + n);//林成
		
		//ArrayIndexOutOfBoundsException - 数组下标越界异常
		//System.out.println(names[100]);
		
		//获取元素个数
		int len = names.length;
		System.out.println("获取元素个数：" + len);//5
		
		System.out.println("-----------");
		
		//遍历 - for循环
		for(int i = 0;i<names.length;i++){
			System.out.println(names[i]);
		}
		
		System.out.println("-----------");
		
		//遍历 - foreach(增强for循环)
		for(String str:names){//遍历数组，依次把元素赋值给str
			System.out.println(str);
		}
		
		/**
			遍历时要使用到下标，就用for循环遍历
			遍历时要不使用到下标，就用foreach遍历	
		*/
	}
}

6.需求

定义一个10个长度的int数组，获取最大值

	public static void main(String[] args){
		
		int[] is = {3,2,4,35,34,5,25,34,32,18};
		
		int max = is[0];//假设数组中第0个下标位置的元素为最大值
		
		for(int i = 1;i<is.length;i++){
			if(max < is[i]){
				max = is[i];
			}
		}
		
		System.out.println("最大值为：" + max);
		
	}
}