目录

         一、静态方法

  • 无参数无返回值的方法
  • 带参数的方法
  • 带返回值的方法

二、方法的重载

三、方法递归

四、用方法编写万年历


一、静态方法

含义:特点功能的代码块。

优点:

        a.解决代码的冗余

        b. 增加了代码的可读性

         c.增加了代码的可维护性

分类:无参数无返回值的方法、带参数的方法、带返回值的方法

1.无参数无返回值的方法:

(1)语法结构:

public static void 方法名( ){
                ...代码块...
}

(2)编写的位置:类里面,方法的外面。

(3)调用静态方法:方法名( )或者 类名.方法名( )

需求:声明一个方法,打印一个5行的三角形。

public class Test{
    public static void main(String[] args){
		method();
	}
	public static void method(){
		for(int i = 0;i<5;i++){
			for(int j = 0;j<=i;j++){
				System.out.print("*");
			}
			System.out.println();
		}
	}
}

2.带参数的方法:

(1)语法结构:

public static void 方法名(参数列表){
                ...代码块...

 }

a.单个参数:

public static void 方法名(数据类型   变量名){
                ...代码块...

 }

调用:方法名(变量名/常量值);

b.多个参数:

public static void 方法名(数据类型  变量名1,数据类型  变量名2,......){
                ...代码块...

 }

调用:方法名(变量名1,变量名2,........);

(2)概念:
            a.形式参数(形参):方法声明时规定的参数;
            b.形参必须指定数据类型;
            c.形参的作用域在整个方法内;
            d.实际参数(实参):调用方法时传入的具体数据;
            e.实参的类型必须和形参的类型兼容;
            f.多个形参或实参用逗号分隔。

需求:声明一个方法,打印三角形,行数和内容由调用方指定。

public class Test{
    public static void main(String[] args){
		//调用
		method(3 ,"$");
		method(5 ,"%");
		method('!',"#");    //ASCII - 33
	}
	public static void method(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();
		}
	}
}

3.带返回值的方法:

(1)语法结构:

public static 数据类型 方法名([参数列表]){
                ...代码块...
                return 数据;

 }

(2)概念:
           a. 方法声明时可以规定返回值的类型;
            b.void表示无返回值,代表调用方法,该方法不会给你返回任何数据;
            c.return后面接的数据是要返回的值;
            d.方法声明时的返回值类型和return后面的具体数据的类型必须兼容;
            e.方法功能的单一性;
            f.返回值的数据只能有一个。

需求:编写一个方法,传入两个int值,比较大小,输出最大值。

import java.util.Scanner;
public class Test{
public static void main(String[] args){
		Scanner scan = new Scanner(System.in);
		System.out.println("请输入第一个数字:");
		int a = scan.nextInt();
		System.out.println("请输入第二个数字:");
		int b = scan.nextInt();
		int max = getMax(a,b);
		System.out.println(max);
	}
	
	public static int getMax(int a,int b){
		int max = (a>b)?a:b;
		return max;
	}
}

编写一个方法考虑顺序:

(1)方法名(做到见名知意)
(2)形参列表
(3)返回值

总结:

(1)一个方法不需要传入数据也不需要返回数据,就使用无参数无返回值的方法;

(2)需要外界将数据传入到方法内部,就使用带参数的方法;

(3)需要将方法内的数据返回给调用放,就使用带返回值的方法。

二、方法的重载

1.方法与方法之间的关系,必须要满足几个条件:

(1)在同一个类里;

(2)方法名必须一致;

(3)参数列表的个数或者类型不一致;

(4)与返回值无关。

2.优点::系统会根据实参的个数和类型自动匹配到对应的方法中

3. 应用场景:在一个类中编写多个方法,多个方法的功能大致一样(说明这几个方法名应该是一样的),细节实现不一样,就考虑使用重载。

需求:编写一个方法,传入两个int值,比较大小,返回最大值;
           编写一个方法,传入三个int值,比较大小,返回最大值;
           编写一个方法,传入两个double值,比较大小,返回最大值;
           编写一个方法,传入三个double值,比较大小,返回最大值。

public class Test{
    public static void main(String[] args){

        int max = getMax(10,20);
        int max = getMax(10,20,30);
        
		//注意:方法有返回值才能打印
        System.out.println(getMax(10.1,20.2));
		System.out.println(getMax(10.1,20.2,30.3));
	}
	
	public static int getMax(int a,int b){
		int max = (a>b)?a:b;
		return max;
	}

	public static int getMax(int a,int b,int c){
		int max = (a>b)?a:b;
		max = (max>c)?max:c;
		return max;
	}
	
	public static double getMax(double a,double b){
		double max = (a>b)?a:b;
		return max;
	}

	public static double getMax(double a,double b,double c){
		double max = (a>b)?a:b;
		max = (max>c)?max:c;
		return max;
	}
}

三、方法递归

1.含义:方法调用方法自身。

需求1:设计一个方法,求n的阶乘;

public class Test{
public static void main(String[] args){
		int num = method(n);    //自己传入数字
		System.out.println(num);    //120
	}
	
	public static int method(int n){
		if(n == 1){
			return 1;
		}else{
			return method(n-1)*n;
		}
	}
}

需求2:不死神兔 - 斐波那契数列

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

public class Test{
    public static void main(String[] args){
		int num = getRabbit(n);
		System.out.println("第n个月兔子的对数:" + num);    //n可以自己设定
	}
	
	public static int getRabbit(int n){
		if(n == 1 || n == 2){
			return 1;
		}else{
			return getRabbit(n-1) + getRabbit(n-2);
		}
	}
}

四、用方法编写万年历

import java.util.Scanner;
public class Test08{
	public static void main(String[] args){
		Scanner scan = new Scanner(System.in);
		System.out.println("请输入年:");
		int year = scan.nextInt();
		System.out.println("请输入月:");
		int month = scan.nextInt();
		
		//计算1900年~输入年的总天数
		int allDayOfYear = getAllDayOfYear(1900,year);
		
		//计算1月~输入月的总天数
		int allDayOfMonth = getAllDayOfMonth(year,1,month);
		
		//计算总天数
		int allDay = allDayOfYear + allDayOfMonth + 1;
		
		//计算星期
		int week = getWeek(allDay);
		
		//计算当月的天数
		int day = getDay(year,month);
		
		//打印日历
		printCalendar(year,month,day,week);
	}
	
	//计算年的总天数
	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 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 boolean isLeapYear(int year){
		if(year%4==0 && year%100!=0 || year%400==0){
			return true;
		}
		return false;
	}
	
	//计算星期
	public static int getWeek(int allDay){
		int week = allDay%7;
		if(week == 0){
			week = 7;
		}
		return 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++){
			num++;
			System.out.print(i + "\t");
			if(num%7 == 0){
				System.out.println();
			}
		}
	}
}

练习:

1.键盘录入一个数据n(1<=n<=9),输出对应的nn乘法表;

import java.util.Scanner;
public class Work01{
	public static void main(String[] args){
		Scanner scan = new Scanner(System.in);
		System.out.println("请输入1~9的数字:");
		int n = scan.nextInt();
		println(n);
	}
	public static void println(int n){
		if(n >= 1 && n <= 9){
			for(int i = 1;i<=n;i++){
				for(int j = 1;j <= i;j++){
					System.out.print(j + "x" + i + "=" + (i*j) + "\t");
				}
				System.out.println();
			}
		}else{
			System.out.println("数据错误");
		}
	}
}

2.素数也叫质数.是除了1和其本身,不能被其他正整数整除的正整数.
     例如:2,3,5,7,11,13,17,19,23.....
      a)写一个方法判断该数是否为素数;(设计成一个方法)
      b)输出某个范围内的所有素数,比如100-200之间。

import java.util.Scanner;
public class Work02{
	public static void main(String[] args){
    Scanner scan = new Scanner(System.in);
		System.out.println("请输入一个数字:");
		int num = scan.nextInt();
        boolean bool = isPrimeNumber(bool);
        System.out.println(num);
        for(int i = 100;i<=200;i++){
			if(isPrimeNumber(i)){
				System.out.println(i);
			}
		}
		
	}
	public static boolean isPrimeNumber(int num){
		if(num <= 1){
			return false;
		}
		
		for(int i = 2;i<num;i++){
			if(num % i == 0){
				return false;
			}
		}
		return true;
	}
}

3.闰年:能被4整除而且不能被100整除,或者能被400整除就是闰年.
    a)判断某个年份是否为闰年(设计成一个方法)
    b)输出一个范围内的哪些年份是闰年(从2000至2020年)

public class Work03{
	public static void main(String[] args){
    Scanner scan = new Scanner(System.in);
		System.out.println("请输入年份:");
		int year = scan.nextInt();
        System.out.println(bool);
        boolean bool = isLeapYear(year);
        for(int i = 2000;i<=2020;i++){
			if(isLeapYear(i)){
				System.out.println(i);
			}
		}
		
	}
	public static boolean isLeapYear(int year){
		if(year%4==0 && year%100!=0 || year%400==0){
			return true;
		}
		return false;
	}
}