方法：实现一个功能。
方法声明：
访问修饰符 返回类型 方法名（参数列表）{
//方法体
}
访问修饰符：public、private、protect、default
返回类型：void——无返回值 任何数据类型：基本数据类型、String类
0,...,n个参数 （类型 名）
方法的定义有四种类型：
无参无返回值 void 方法名(){ }
无参带返回值 如：Scanner类提供的next()方法，返回值是String类型 public int area(){ return int 型值}
带参带返回值 public void max(float a,float b){ }
带参带返回值 public int fac(int n){ }
定义的方法，在类的内部，与主方法并列，主方法是程序的入口，主方法若需要调用其它方法，需要创建类的对象，使用对象名.方法名()去调用其它方法。除了主方法的其它方法之间可以直接互相调用，可以不创建对象去调用。 （因为一个类的成员属性和成员方法是属于实例化对象去拥有的。）
方法不能嵌套定义，不能把定义的方法写在主方法里。
数组作为方法参数
输出数组元素的值
public class ArrayMethod { public void printArray(int[] arr){ //输出数组元素的值 for(int i=0;i<arr.length;i++){ System.out.println(arr[i]+" "); } System.out.println(); } public static void main(String[] args){ int[] arr={1,2,3,4,5}; ArrayMethod a=new ArrayMethod(); a.printArray(arr); } }
查找数组元素的值 ——方法参数为：数组，要查找的元素 ——返回值 boolean类型
import java.util.Scanner; public class ArraySearch { //查找数组元素值的方法 public boolean search(int n,int[] arr){ boolean flag=true; //默认是没找到 for(int i=0;i<arr.length;i++){ if(arr[i]==n){ flag=true; //找到了 break; //提高程序查询效率 } } return flag; } public static void main(String[] args){ int[] arr1={1,2,3,4,5}; System.out.println("请输入要查找的数据:"); Scanner sc=new Scanner(System.in); int n1=sc.nextInt(); ArraySearch as=new ArraySearch(); boolean flag=as.search(n1,arr1); if(flag) System.out.println("找到了"); else System.out.println("没找到"); } }
方法重载
方法名相同，参数列表不同（个数、类型、名），与返回值类型无关。
public class MathDemo { //求两个int类型数的和 public int plus(int m,int n){ return m+n; } //求两个double类型数的和 public double plus(double m,double n){ return m+n; } //求数组元素的累加和 public int plus(int[] arr){ int sum=0; for(int i=0;i<arr.length;i++){ sum=sum+arr[i]; } return sum; } public static void main(String[] args){ int m=5,n=10; int[] arr={1,2,3,4,5}; MathDemo mathDemo=new MathDemo(); System.out.println("int类型的和:"+mathDemo.plus(m,n)); System.out.println("double类型的和:"+mathDemo.plus(1.2,3.4)); System.out.println("数组元素的和:"+mathDemo.plus(arr)); } }
参数的传值问题
Java中处理8种基本的数据类型用的是值传递，其它所有类型都用的是引用传递。8种基本数据类型的包装类型都是不可变量。
1.值传递
public class ExchangeDemo { public void swap(int a,int b){ int temp; System.out.println("交换前:a="+a+",b="+b); temp=a;a=b;b=temp; System.out.println("交换后:a="+a+",b="+b); } public static void main(String[] args){ int m=4,n=5; ExchangeDemo ed=new ExchangeDemo(); System.out.println("交换前:m="+m+",n="+n); ed.swap(m,n); System.out.println("交换后:m="+m+",n="+n); } public void swapTest(){ int m=4,n=5; System.out.println("交换前:m="+m+"n="+n); swap(m,n); System.out.println("交换后:m="+m+"n="+n); } } //运行结果 交换前:m=4,n=5 交换前:a=4,b=5 交换后:a=5,b=4 交换后:m=4,n=5
主方法中调用方法必须要通过对象调用，与方法同类下的其它方法，无需创建对象，可直接调用。
2.引用传递（数组作为方法参数）
public class ArrayDemo { //定义一个用于修改某个数组元素值的方法 public void updateArray(int[] a){ a[3]=15; System.out.println("数组a的元素为:"); for(int n:a){ System.out.print(n+" "); } System.out.println(); } public static void main(String[] args){ ArrayDemo ad=new ArrayDemo(); int[] a1={1,2,3,4,5}; System.out.println("方法调用前数组a1的元素为:"); for(int n:a1){ System.out.print(n+" "); } System.out.println(); ad.updateArray(a1); //数组传值，a1和a指向了同一块内存空间(即同一数组)形参的改变影响了实参的值 System.out.println("方法调用后数组a1的元素为:"); for(int n:a1){ System.out.print(n+" "); } } } //运行结果 方法调用前数组a1的元素为: 1 2 3 4 5 数组a的元素为: 1 2 3 15 5 方法调用后数组a1的元素为: 1 2 3 15 5
引用传递：传递的是地址，形参和实参指向同一块存储单元。
值传递：基本类型传递的是值，形参用实参的值初始化了一个临时的存储单元，值虽相同，但存储单元不同，因此形参的改变不影响实参的值。
即：基本数据类型变量传值无影响，引用数据类型（数组、对象）传值有影响。
public class Test { public static void changeStringBuffer(StringBuffer ss1,StringBuffer ss2){ ss1.append("World"); ss2=ss1; } public static void main(String[] args){ Integer a=1; Integer b=a; //(1) b++; System.out.println(a); System.out.println(b); StringBuffer s1=new StringBuffer("Hello"); StringBuffer s2=new StringBuffer("Hello"); changeStringBuffer(s1,s2); System.out.println(s1); System.out.println(s2); //(2) } }
（1）Integer类型是按引用传递，不是值传递，既然是引用传递，为什么b的改变没有带来a的改变？因为Integer是不可变类，创建一个新值为2的Integer赋值给b，b与a已经无关系。
（2）
可变参数列表
public void sum(int... n){ }
public class ArgsDemo { //求和 public void sum(int... n){ int sum=0; for(int i:n){ sum=sum+i; } System.out.println("sum="+sum); } public static void main(String[] args){ ArgsDemo ad=new ArgsDemo(); ad.sum(1); ad.sum(1,2); ad.sum(1,2,3); } } //运行结果 sum=1 sum=3 sum=6
1.参数列表中如果有两个以上的参数，可变参数一定是在最后的（前面的参数都匹配完了，剩下的都是可变参数类型，如果把可变参数放在前面，无法判断到底应用有几个参数）。
2.一个方法中只能有一个可变参数。
3.可以将数组传递给可变参数列表。但数组作为参数时，是不能将多个值传递给数组的。
public class ArgsDemo1 { //查找 public void search(int n,int... a){ boolean flag=false; for(int a1:a){ if(a1==n){ flag=true; break; } } if(flag){ System.out.println("找到了!"+n); }else{ System.out.println("没找到!"+n); } } public static void main(String[] args){ ArgsDemo1 ad1=new ArgsDemo1(); ad1.search(3,1,2,3,4,5); //找到了!3 int[] a={1,2,3,4,5}; ad1.search(3,a); //找到了!3 } public void search(int n,int[] a){ //报错 } } //运行结果 找到了!3 找到了!3
上述最后一段代码报错原因：在方法定义中，认为当前的两个search方法重复定义，而不是重载。
数组作为参数时，是不能将多个值传递给数组的。
public void search(int n,int[ ] a){ }
ad1.search(3,1,2,3,4,5); //报错
4.可变参数列表所在的方法是最后被访问的，只要有其它相关方法，它就不会被执行。
public class ArgsDemo2 { public int plus(int a,int b){ System.out.println("不带可变参数的方法被调用"); return a+b; } public int plus(int... a){ int sum=0; for(int n:a){ sum=sum+n; } System.out.println("带可变参数的方法被调用"); return sum; } public static void main(String[] args){ ArgsDemo2 ad=new ArgsDemo2(); System.out.println("和为:"+ad.plus(1,2)); } } //运行结果 不带可变参数的方法被调用 和为:3
原文：https://www.cnblogs.com/tendo/p/10497204.html