JavaSE学习笔记 Day6

JavaSE学习笔记 Day6

[上一篇](https://blog.csdn.net/CHiN_951/article/details/134720702?spm=1001.2014.3001.5502)

---

---

···

五、方法

5.1什么是方法

可以封装为了解决某个问题的代码片段,称之为方法
方法可以被重复的调用

5.2方法组成部分

public static void main(String[] args) {}
//main方法,又被称为主方法,是现阶段jvm唯一识别的方法,也是程序的入口

解析:
public 公共的,方法的访问权限修饰符,表示任何类都可以直接访问
static 静态的,方法的修饰符
void 空白的,无返回值的 方法返回值类型之一
main 主要的,方法名(可以自定的)
() 方法的参数列表
{} 方法的主体(方法体),在方法体内部可以编写代码段
String[] 参数,类型为字符串数组
args 参数名，参数就是变量

方法的重要组成部分:
方法的定义
方法体

public class Demo01 {

//	自定义方法:打印分割线,只要调用就会输出显示
	public void myPrint() {
		System.out.println("-------------分割线-------------");
	}
	
	public static void main(String[] args) {
//		方法的调用
//		1.创建当前类的对象(变量)
		Demo01 demo01 = new Demo01();
		
//		2.使用当前类的对象,打点调用对应方法 demo01对象的myPrint()方法
//		调用10次就执行10次方法
		demo01.myPrint();
		demo01.myPrint();
		demo01.myPrint();
	}
}

5.3方法名

可以自定义,除main以外(是jvm识别的)
类似于变量名
组成:数字，字母，下划线，美元符
数字不能开头
首字母小写
驼峰命名法则
方法名建议使用动词,变量建议使用名词

区分变量和方法
 看(),有括号的就是方法,没有的就是变量

5.4方法的调用

1.创建方法所在类的对象
 例如:Demo01 d01 = new Demo01();
2.使用对象.的形式调用自定方法
 例如:d01.myPrint();

public class Demo02 {

	public void xiao() {
		System.out.println("hahahahahaha");
	}
	
	public void ku() {
		System.out.println("wuwuwuwuwuwu");
	}
	
	public static void main(String[] args) {
//		想调用Demo02中的方法,就需要去创建Demo02的对象
		Demo02 d02 = new Demo02();
//		方法就打点调用的形式,点可以翻译为的
		d02.xiao();
		d02.xiao();
		d02.xiao();
		
		d02.ku();
	}
}

5.5自定义方法

语法
访问权限修饰符 修饰符 返回值 方法名(参数列表) {
 方法体;
 [return [返回值]];
}

5.5.1简单方法(无参数无返回值)

语法
public void 方法名() {
}

public class Demo03 {

	public void run() {
		System.out.println("liao...");
	}
	
	public static void main(String[] args) {
//		new 类型();使用ctrl+2 选择L创建对象
		Demo03 demo03 = new Demo03();
//		方法不调用不会执行
		demo03.run();
		
	}
}

5.5.2有参无返回值方法

语法
public void 方法名(参数列表) {
}

参数列表被称为形参(形式参数)
形参起占位作用,可以在方法内部直接使用,无需关心具体值是什么
在方法调用时为形参赋值
赋值方式:
 对象名.方法名(实参);
实参:实际参数,为形参赋值的,和形参的关系是一一对应的

public class Demo04 {

//	定义有参方法,根据成绩打印不同的等级
	public void level(int score/*形参,就是变量 可以在方法内部直接使用,不用关心值*/) {
//		在方法内部的执行顺序:从上到下,从左向右
		switch (score / 10) {
		case 10:
		case 9:
			System.out.println("A");
			break;
		case 8:
			System.out.println("B");
			break;
		case 7:
			System.out.println("C");
			break;
		case 6:
			System.out.println("D");
			break;
		default:
			System.out.println("E");
			break;
		}
	}
	
	public static void main(String[] args) {
		Demo04 demo04 = new Demo04();
//		调用时,需要为形参进行赋值
//		进行赋值的参数为实参,实参与形参之间是一一对应的
		demo04.level(70);
		demo04.level(60);
		demo04.level(88);
		demo04.level(100);
		demo04.level(56);
	}
}

5.5.3无参有返回值方法

方法调用之后,结果就是返回值,若没有返回值使用void进行占位

语法
public 返回值类型 方法名(){
 return 返回值;
}

返回值类型:是一个数据类型
返回值:是为对应的类型进行赋值的

public class Demo05 {

//	定义方法计算1~100和,并返回
	public int sum() {
		int sum = 0;
		for(int i = 1;i<=100;i++) {
			sum+=i;
		}
//		将sum返回给方法,调用者可以使用
		return sum;
	}
	
	public static void main(String[] args) {
		Demo05 demo05 = new Demo05();
//		1.接收返回值
		int sum = demo05.sum();//sum()返回值类型为int
//		2.使用返回值
		System.out.println("1~100的和为"+sum);
		
//		上述两部可以省略
		System.out.println(demo05.sum());//方法有返回值可以直接使用输出
//		输出语句不是写程序是必须携带的语句,输出语句往往是测试时显示数据使用的
	}
}

5.5.4有参有返回值方法

语法
public 返回值类型 方法名(参数列表){
 return 返回值;
}

public class Demo06 {
//	有参数有返回值方法,定义功能,将返回的结果给调用者
//	定义方法 传入两个参数,返回两个参数之间数值的和
	public int sum(int min,int max) {
		int sum = 0;
		for(int i = min;i<=max;i++) {
			sum += i;
		}
		return sum;
	}
	
//	定义方法 获取两个数之间的最大值
	public int getMax(int a,int b) {
		return a > b ? a : b;
	}
	public static void main(String[] args) {
		Demo06 demo06 = new Demo06();
		
		int sum = demo06.sum(1, 100);
		System.out.println(sum);
		
		sum = demo06.sum(100, 200);
		System.out.println(sum);
		
		int max = demo06.getMax(10, 20);
		System.out.println(max);
		
		max = demo06.getMax(30, 55);
		System.out.println(max);
	}	
}

5.6return关键字

作用:结束当前方法
 1.配合返回值一起使用,将返回值给调用者(必须是在有返回值方法中使用)
 2.结束当前方法,后面没有任何值,可以在任意方法中使用
在return之后不能写任何的代码

public static void main(String[] args) {
    for(int i = 1;i<=100;i++) {
        if(i == 7) {
            //				break;//中断循环
            return;//结束方法
        }
    }

    System.out.println("我被执行了");
}

5.7方法的细节和好处

细节:
 1.方法定义的位置,在一个类中,其他方法的之外。所有方法是并列关系。方法之间是不可以嵌套的
 2.方法之间是没有先后顺序的。调用者决定它们的执行顺序,不调用不会执行
 3.方法形参和实参之间必须保持一致(参数个数,参数类型,参数顺序)
 4.方法的返回值,不要乱用,不是说所有的方法都需要返回值,没有意义的返回值不如不写
 5.定义方法时,要遵从程序设计的单一职责(java设计原则之一,目的为了降低耦合度)。一个方法只做一个功能
好处:
 减少冗余代码(重复的代码),便于维护和修改,提高代码的执行效率,提高代码的通用性

public class Demo08 {
//	定义方法,传入月份,获取到对应的天数
	public int getDay(int year,int month) {
		switch (month) {
		case 4:
		case 6:
		case 9:
		case 11:
			return 30;
		case 2:
			if((year % 4 == 0 && year % 100 != 0) || year % 400 ==0 ) {
				return 29;
			}else {
				return 28;
			}
		default:
			return 31;
		}
	}
	
	public static void main(String[] args) {
		Demo08 demo08 = new Demo08();
		System.out.println(demo08.getDay(2024, 2));
	}
}

5.8方法的重载

同类中:同名不同参
 参数不同体现在:个数不同,类型不同,顺序不同
在java中一个类中存在同名的方法
可以解决因同类型方法过多导致的名字不好起,使用重载方法便于记忆.
 例如:System.out.println(参数);该方法就是一个重载方法

重载方法的调用,会默认的匹配最符合的方法

public class Demo09 {

//	实现加法运算
//	下面的功能可以使用方法重载进行优化
//	方法重载:同名不同参
//	不同参:个数,类型,顺序(和形参的名字没有关系)
	public int add(int a,int b) {
		System.out.println("int+int");
		return a + b;
	}
	
	public double add(double a,double b) {
		System.out.println("double+double");
		return a + b;
	}
	
	public double add(int a,double b) {
		System.out.println("int+double");
		return a + b;
	}
	
	public double add(double a,int b) {
		System.out.println("double+int");
		return a + b;
	}
	
	public int add(int a,int b,int c) {
		System.out.println("int+int+int");
		return a + b + c;
	}
	
	public double add(double a,double b,double c) {
		return a + b + c;
	}
	/*public double add(int c,double d) {
		return c + d;
	}*/
	
	public static void main(String[] args) {
		Demo09 demo09 = new Demo09();
		
		demo09.add(10.0, 10.1);
		demo09.add(1, 1);
		demo09.add(1, 1, 1);
		demo09.add(10.1, 1);
		demo09.add(1, 10.1);		
	}
}