Java 静态方法支持泛型么

转载

mob64ca1409970a 2024-10-29 22:07:52

文章标签 Java 静态方法支持泛型么大数据 java 开发语言 System 文章分类 Java 后端开发

一、静态方法

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

二、方法的重载

三、方法递归

四、用方法编写万年历

一、静态方法

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

优点：

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

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。