Java中的方法就是类似于其他语言的函数，是一段完成特定功能的代码片段，一般情况下，定义一个方法的包含以下几种方法:
方法包含一个方法头和一个方法体，下面是一个方法的所有部分；
**修饰符:**修饰符是可选的告诉编译器如何调用该方法，定义了该方法的访问类型。
**返回值类型：**方法可能会有返回值，returnValueType是方法的返回值的数据类型；有些方法需要执行所需操作，但是没有返回值，在这种情况下returnValueType的关键字是void.
**方法名：**是方法的实际名称，方法名和参数表共同构成方法签名，
**参数：**参数就像是一个占位符，当前方法被调用时，传递值给参数，这个值被称为参数或者变量，，参数列表是指方法的参数类型，顺序，和参数个数，。参数是可选的，方法可以不包含任何参数。
形式参数：在方法被调用时用于接收外界的输入的数据。
实参：调用方法时实际传给方法的数据。
**方法体：**方法体包含具体的语句，定义该方法的功能。
案例1-1
写一个比较大小的方法；
package com.Hai.method;
import java.util.Scanner;
public class Dem01 {
public static void main(String[] args) {
Scanner scanner=new Scanner(System.in);
System.out.println("请输入两个整型的数据：");
int i1=scanner.nextInt();
int i2=scanner.nextInt();
int max= max(i1,i2);
System.out.println("更大的数是："+max);
scanner.close();
}
//这是比大小的方法
public static int max(int num1,int num2){
int result=0;
if(num1==num2){
System.out.println("结果相等");
return 0;//终止方法
}
if(num1>num2){
result=num1;
}else {
result=num2;
}
return result;
}
}
2 方法的重载
方法的重载就是方法名字可以相同，但是参数类型不同，参数的个数也可以不同
方法重载的规则如下：
方法的名称必须相同参数列表必需不同（方法的个数，类型，排列顺序不同）方法的返回类型可以相同也可以不同仅仅是方法的返回类型不同不足以构成方法的重载
实现理论：
方法名称相同时，编译器会根据调用方法的参数个数，参数类型去逐一匹配，以选择对应的方法，如果匹配失败，则编译器报错。
案例2-1
package com.Hai.method;
import javax.sound.midi.Soundbank;
import java.util.Scanner;
public class addMethod {
public static void main(String[] args) {
Scanner scanner=new Scanner(System.in);
System.out.println("请输入两个数：");
double d1=scanner.nextDouble();
double d2=scanner.nextDouble();
double sum=add(d1,d2);//求两个数的和
System.out.println(sum);
System.out.println("=======================");
System.out.println("请输入三个数：");
int i1=scanner.nextInt();
int i2=scanner.nextInt();
int i3=scanner.nextInt();
int sum2=add(i1,i2,i3);//求三个数的和
System.out.println(sum2);
scanner.close();
}
//求两个数的和
public static double add(double d1,double d2){
double sum=0;//用于统计和的变量
sum=d1+d2;
return sum;
}
//重载求和的方法，求三个整数的和
public static int add(int a,int b,int c){
int sum=0;//用于统计和的变量
sum=a+b+c;
return sum;
}
}
3 java使用命令行编译
首先在新建一个类Dem03，写代码如下：
package com.Hai.method;
public class Dem03 {
public static void main(String[] args) {
for (int i=0;i
打开文件路径进型编译 ，进入cmd
命令行编译如下：
4 可变参数
当我们写方法的时候，可能因为有多个参数，可能要写多个方法名相同参数不同的方法，这样非常的麻烦。可以通过可变型参数，不规定你要传递的参数个数；
要求如下：
在方法声明中，在指定参数类型后加一个省略号（…）一个方法中只能有一个指定的可变参数，他必须是方法的最后一个参数。任何普通参数都必须在他之前声明。
案例4-1
使用可变型参数求三个数的和
package com.Hai.method;
public class Dem04 {
public static void main(String[] args) {
Dem04 dem04=new Dem04();//new 一个对象
dem04.test(15.4,14,45);//对象.方法名，使用方法。
}
public static void test(double num,int...i){
int a1=i[0];//使用数组的方式取得第一个可变参数；
int a2=i[1];//使用数组的方式得第2个可变参数
double d=num;
double sum=a1+a2+num;
System.out.println(sum);
}
}
案例4-2
定义一个可变参数的方法，求出最大值
package com.Hai.method;
public class Dem05 {
public static void main(String[] args) {
Dem05 dem05=new Dem05();
dem05.println(15,12,45,56,34,100);
println(new double[]{1,2,3,44});
}
//定义一个可变参数的方法，求出这个方法的最大值
public static void println(double...number){
if(number.length==0){
System.out.println("No argument passed");
return;
}
double result=number[0];
//找出最大值
for(int i=1;iresult){
result=number[i];
}
}
System.out.println("The Max Value is "+result);
}
}
5 递归
自己调用自己就是递归。利用递归可以用简单的程序解决一些复杂的问题。通常把一个大型复杂的问题层层转化为一个与原问题相似的规模的小问题来求解，递归策略只需要少量的程序 就可描述出求解的过程所需要的的多次重复计算，大大的减少了程序的代码量，递归的能力在于用有限的语句来定义对象的无限集合。
递归结构包含两部分：
递归头：什么时候不调用自身方法。如果没有头，将陷入是循环。递归体：什么时候需要调用自身方法。
案例5-1
求n的阶乘。
package com.Hai.method;
public class Dem06 {
public static void main(String[] args) {
System.out.println(f(5));
}
public static int f(int n){
if(n==1){
return 1;
}else {
return n*f(n-1);
}
}
}
注意
递归容易导致栈溢出，小的递归可以使用，当需要大量的压栈时，可能导致物理内存的崩溃。
