一、方法：
1.目的：
对功能的封装，实现对代码的复用
eg:
public class MethodStart {
public static void main(String[] args) {
printHello();
}
public static void printHello(){
System.out.println("-------------- printHello --------------");
for (int i = 1; i <6 ; i++) {
System.out.println("HelloWorld\t"+i);
}
}
}
2.声明：
[权限修饰符] static 返回值类型 方法名([形参列表]){ 方法体 }
3.调用:
方法名();
4.注意:
1.方法调用才会执行
2.方法与方法是兄弟姐妹关系，地位相同，在类中声明
3.方法执行完毕回到方法调用处（如果方法没有返回值，则回到调用方法的下一行）
eg:
public class Method01
//程序的入口
public static void main(String[] args) {
System.out.println("1111");
show();
System.out.println("3333");
//printHello();
}
//方法的声明
public static void show(){
int m = 10;
System.out.println("this is show()");
printHello();
}
//方法的声明
static void printHello(){
int n = 10;
System.out.println("HelloWorld");
}
}
5.方法的组成部分分解One：
形参列表：扩展了程序的功能
形参：位置在方法的声明处，方法名（数据类型 变量名,数据类型 变量名,数据类型 变量名...），也约束了实参的类型和数量
实参：在方法的调用处，给形参赋值
eg:
public class Method02 {
public static void showNum(double num){
System.out.println("num = " + num);
}
public static void main(String[] args) {
int m =99;
showNum(m);
//调用方法
sum(333,666);
System.out.println("---------");
sum(20,40);//实参
System.out.println("-------------------");
showStr("安琪拉");
}
/**
* 展示信息的方法
* @param message 信息内容
*/
public static void showStr(String message){
System.out.println("message = " + message);
}
/**
* 获取任意两个整数的和
* @param a 第一个整数
* @param b 第二个整数
*/
public static void sum(int a,int b){//形参
System.out.println("a = " + a);
System.out.println("b = " + b);
System.out.println(a+b);
/* int m = 10;
int n = 20;
System.out.println(m+n);*/
}
}
6.方法的组成部分分解Two：
返回值类型：此方法的结果是下一次执行的条件
void：当前方法没有返回值
数据类型：如果返回值是一个数据类型 则[必须]返回一个满足类型要求的值
eg：
//这段代码中isEven（）方法的返回值决定着main方法中for循环的执行条件
public class Method03 {
public static double getSum(int a, int b) {
return a + b;
}
public static void main(String[] args) {
double sum = getSum(10, 20);
System.out.println("sum = " + sum);
/* boolean result = isEven(20);
System.out.println("result = " + result);
System.out.println(isEven(31));*/
for (int i = 1; i < 101; i++) {
boolean flag = isEven(i);
if (flag) {
System.out.println("i = " + i);
}
}
}
/**
* 定义方法判断传入的整数是否为偶数 是 true false
*
* @param num 要判断的数字
* @return 是否为偶数
*/
public static boolean isEven(int num) {
if (num % 2 == 0) {
return true;
} else {
return false;
}
}
}
二、方法的重载
为什么要进行方法的重载呢？
在同一类中使用相同的方法名表示不同细节实现的方法
方法重载的注意点：
- 同一类中同一方法名不同的形参列表（不同的形参列表：类型 顺序 个数）
- 与返回值类型和修饰符无关
下面是重载的一个简单案例：
public class MathTools {
//求两个整数的最大值
public static int max(int a,int b){
return a>b?a:b;
}
//求两个小数的最大值
public static double max(double a, double b){
return a>b?a:b;
}
//求三个整数的最大值
public static int max(int a, int b, int c){
return max(max(a,b),c);
}
//求n整数的最大值
public static int max(int... nums){
int max = nums[0];//如果没有传入整数，或者传入null，这句代码会报异常
for (int i = 1; i < nums.length; i++) {
if(nums[i] > max){
max = nums[i];
}
}
return max;
}
}
三、可变参数
当定义一个方法时，形参的类型可以确定，但是形参的个数不确定，那么可以考虑使用可变参数。
可变参数的格式:
public 返回值类型 方法名(【非可变参数部分的形参列表,】参数类型... 形参名){
}
可变参数的特点：
- 一个方法最多只能有一个可变参数,且必须位于参数列表的最后(语法规定)
- 如果一个方法包含可变参数，那么可变参数必须是形参列表的最后一个
- 在声明它的方法中，可变参数当成数组使用（因为可变参数底层使用数组进行数据存储）
- 可变参数中实参的数量是[0,n]
下面是一个简单的关于可变参数代码案例：
public class NumberTools {
public static int total(int[] nums){
int he = 0;
for (int i = 0; i < nums.length; i++) {
he += nums[i];
}
return he;
}
public static int sum(int... nums){
int he = 0;
for (int i = 0; i < nums.length; i++) {
he += nums[i];
}
return he;
}
public static void main(String[] args) {
System.out.println(NumberTools.sum());//0个实参
System.out.println(NumberTools.sum(5));//1个实参 System.out.println(NumberTools.sum(5,6,2,4));//4个实参
System.out.println(NumberTools.sum(new int[]{5,6,2,4}));//传入数组实参
System.out.println("------------------------------------");
System.out.println(NumberTools.total(new int[]{}));//0个元素的数组
System.out.println(NumberTools.total(new int[]{5}));//1个元素的数组
System.out.println(NumberTools.total(new int[]{5,6,2,4}));//传入数组实参
}
}
四、方法的值传递
1.基本数据类型（实际上传递的是值的副本）
说到这里肯定就疑惑了，那么什么是副本呢？
public class ChangeValue1 {
public static void main(String[] args) {
int m = 10;
int n = 20;
System.out.println("方法调用前 m = " + m+", n = "+ n);
swap(m,n);
System.out.println("方法调用后 m = " + m+", n = "+ n);
}
public static void swap(int m, int n) {
int temp =m;
m = n;
n =temp;
System.out.println("方法调用中 m = " + m+", n = "+ n);
}
}
从以上代码可以看出：
在Java中，基本类型数据的值传递是指将该数据的值复制一份，传递给方法或赋值给另一个变量。这里的“副本”指的是复制的这份值，它与原始数据值是独立的，修改其中一个的值不会影响另一个的值。因此，基本类型数据的值传递可以看作是将原始数据的一个副本传递给方法或变量进行操作，而不是直接传递原始数据本身
再进行一个简单例子举例：
假设有如下的代码：
int x=10;
modifyValue(x);
modifyValue的方法定义如下：
public static void modifyValue(int value) {
value = value + 1;
System.out.println("Modified value: " + value);
}
通过代码我们可以非常容易地看出来，在调用modifyValue方法时，实际上传递给该方法的是x的值的副本，而不是x本身。因此，在modifyValue方法内部修改value的值不会影响x的值，x的值仍然是10
2.引用数据类型（传递的是地址值）
public class ChangeValue2 {
public static void main(String[] args) {
String[] arr = {"安琪拉","米莱迪","妲己"};
System.out.println("交换前："+ arr[0]);//安琪拉
swap(arr);
System.out.println("交换后："+ arr[0]);//林志玲
}
public static void swap(String[] arr) {
arr[0]="林志玲";
System.out.println("交换中："+ arr[0]);//林志玲
}
}
通过上面的代码可以知道当我们在main方法中调用swap方法的时候，传参给了swap方法中的形参，促使了swap方法中arr的地址指向main方法中的arr，他们指向了同一个地址，由于提供了arr[0]="林志玲"对数组中的内容进行了修改，所以交换后打印的arr[0]也是林志玲
