一、方法
方法的概念
将一个功能抽取出来，放在类中的大括号中， 形成一个独立的功能 ， 当需要使用该功能时，则调用它， 这样可以增强代码的复用性（重复利用） ，并解决代码的冗余现象。
方法的语法：
[访问修饰符] 返回值类型 方法名( [参数类型 参数名1 , 参数类型 参数名2 ...] ){
方法体
}
详解：
访问修饰符： 用于修饰这个方法的调用范文 目前默认 public static
返回值类型： 无返回值就写void 或者 方法执行后返回的结果的数据类型 ，方法执行完之后会将结果返回
方法名 ： 给方法取名， 准寻标识符的规则
参数类型 、参数名： 它们是同时定义 ，方法在执行时未知的数据，需要在调用方法时进行传递值。 参数类型表示 这个参数的数据类型 ，参数名就是一个参数名称 这个参数名可以在方法体中使用。
方法体： 这个方法具有的功能（代码块）
定义一个方法
public static int add（int num1 ， int num2）{
return num1+num2;
}
根据方法的参数 不同，返回值不同，可以将方法分为四类：
1、无参无返回值方法
语法：
public static void 方法名(){
方法体
}
2、无参有返回值方法
语法：
public static 返回值类型 方法名 (){
方法体
}
结果在n中
3、有参无返回值方法
语法：
public static void 方法名(参数列表 ){
方法体
}
情况一、 当参数中是基本数据类型 ，将实参的值赋值给 形参
public static void add(int num){
num++;
System.out.println("方法中 num 的值："+num);
}
调用方法： num的改变不会改变n 的值 ，因为是两个独立的内存
int n =10;
System.out.println(n);
add(n);
System.out.println("方法外面 实参的值："+n);
结果输出：
方法中 num 的值： 11
方法外面 实参的值：10
情况二： 当参数的数据类型是引用数据类型
例如 数组 、类
// 方法的比对 参数是数组
public static void add(int [] arr){
arr[0]++;
System.out.println("方法中 arr[0]="+arr[0]);
}
调用：
int [] array ={10,20};
add(array);// 会调用 参数是数组的add方法
System.out.println("方法外面的 arr[0]="+ array[0]);
结果：
方法中 arr[0]=11
方法外面的 arr[0]=11
类的调用：
public static void addAge(Student student){
// 将学生的年龄 获取 自加
int age = student.age;
age++;
// 在重新赋值
student.age=age;
}
调用
Student student = new Student(); // age默认为 18
System.out.println("方法调用之前： "+student.age); // 18
addAge(student); // 传的地址
System.out.println("方法外面 学生的年龄："+student.age);
结果输出： 方法调用之前： 18
方法外面 学生的年龄：19
/**
* 以上方法调用 的结论： 对于参数为引用数据类型，方法外面和方法内部公用同一块内存，
* 也就是说 参数再传递时，将引用类型的地址赋值给 方法的形参
* 对于基本数据类型 ，方法的参数将 值的副本赋值给形参，这样形参的改变
* 不会影响实参的值
* 原因： 引用数据类型在参数传递时 是地址 （JVM对于堆内存的大小不可控）
* 基本数据类型在参数传递时 是值
*
*/
情况三、 当参数是String类型时 ，String是引用数据类型 ，但是在参数传递时，是与基本类型一样
public static void main(String[] args) {
// 参数是字符串
String uname ="李四";
sayHello(uname);
System.out.println("我最后对"+uname+"sayHello");
}
public static void sayHello(String name){
name="张三";
System.out.println("我对"+name+"sayHello");
}
结果：
我对张三sayHello
我最后对李四sayHello
4、有参有返回值方法
语法：
public static 返回值类型 方法名(参数列表){
方法体
}
例如 ：
public static String sayHello(String name){
name="张三";
System.out.println("我对"+name+"sayHello");
return name ;
}
调用
public static void main(String[] args) {
// 参数是字符串
String uname ="李四";
// 将返回值接收 ，这是 uname 才被改变 ，如果不接受，则不改变
uname = sayHello(uname);
System.out.println("我最后对"+uname+"sayHello");
}
结果：
我对张三sayHello
我最后对张三sayHello
二、方法的调用以及方法参数传递
1、方法的定义：
访问修饰符 返回值类型 方法名 （[参数列表]）{
方法体
}
如果方法体中需要一些未知的数据作为执行条件，那么这些数据可以作为参数。
如果方法需要返回数据，在定义有返回值的方法，且需要明确返回值类型
方法调用两种方式：
1、 对象名.方法名(参数)
2、直接写方法名调用 ，但必须是static修饰的
// 获取这个字符串的第一个字符
public static char method1(String str){
return str.charAt(0); //获取字符串的第一个字符
}
//方式一： 调用方法
对象名.method1()
//方式二： 调用静态方法 （static修饰的）
String s ="abc";
char c = method1（s）// s将赋值给 方法的形参 str ，那么方法执行时str有值
// c 就是方法调用后的返回值
1、方法的参数是基本数据类型 ，它传递的是 值
// 计算一个数的平方
public static int pow(int a){
a=a+2; // 6
return a*a; // 6*6 = 36
}
main:
int num=4;
int sum = pow(num); //num实参 num赋值给a
System.out.println(num); // 4
System.out.println(sum); // 36
2、方法的参数是引用数据类型，它传递的是地址 （String类型除外）
//参数 是数组类型
public static int pow(int [] arr){
arr[0]=arr[0]+2; //根据地址 改变数组的第一个元素值 arr[0]=4;
return arr[0]*arr[0]; // 4*4
}
调用
// 调用另一个pow
int [] array = {2,3};
int sum2 = pow(array) ; // array中存放数组的地址 ，将地址赋值给 arr形参
System.out.println(array[0]);// 4
System.out.println(sum2 ); // 16
方法的重载：
在一个类中，存在相同方法名的两个及以上的方法，且他们的参数列表不同（参数类型不同 ，参数个数不同，参数顺序不同），不考虑参数名，不考虑返回值类型
一个类中不能存在完全相同的方法，他们是重复的方法 JVM编译不通过
例如：
public int add(int a ,int b){
return a+b;
}
public int add(long a,long b){
return (int)(a+b);
}
//与前两个 不重载
public void add(int c,int d){
}
// 能与 方法1 ，2 构成重载
public void add(int a){
}
// 能与 方法1 ，2 构成重载
public void add(int a ,long b){
}
// 能与 方法1 ，2 构成重载
public void add(long a ,int b){
}
把握： 方法名是否相同，同时 参数列表是否不同 （参数个数不同 或者参数类型不同或者参数顺序不同）
在一个方法可以调用其他的方法， 它们的执行流程
/**
* 程序入口
* @param args
*/
public static void main(String[] args) {
System.out.println("这里是main方法的开始");
method1();
System.out.println("这是main方法的结束");
}
// 在一个方法中可以调用另一个方法， 它们的执行顺序是这样的
public static void method1(){
System.out.println("这是method1 的开始语句块 ");
// 调用method2
method2();
System.out.println("这是method1的 结束语句块");
}
public static void method2(){
System.out.println("这是method2 的开始语句块 ");
// 调用method3
method3();
System.out.println("这是method2 的结束语句块");
}
public static void method3(){
System.out.println("这是method3的执行语句块");
}
三、方法的递归调用
1、定义
在一个方法中，运行方法自身调用，这样的调用称为方法的递归调用， 为了避免出现方法调用时出现死循环，递归调用中必须定义 方法结束调用的条件。
方法递归调用执行流程
public static void m3(int i){
if(i==5){
return ;
}
System.out.println("这是m3方法开始i :"+ i);
i++;
m3(i);
System.out.println("m3方法的结束 i:"+ i );
}
public static void main(String[] args) {
m3(0); //
}
练习1 ： 使用递归计算一个数的阶乘
n =5 = 5! = 5*4的阶乘
f(n) = n* f(n-1) =
(n-1)*f(n-1-1)
public static int f(int n ){
if(n==1){
return 1;
}
int s = n*f(n-1);
System.out.println("结束 --"+s);
return s;
}
// n =5 n=4 n=3 n=2 n=1 return 1
// s = 5*f(4) s=4* f（3） s= 3* f(2) s=2*f(1)
// s=5*24 s=4* 6 s=3* 2= 6 s=2
// s = 120
练习2 ： 一组序列 1 ，1, 2，3, 5 , 8... n， 第12个数 为多少？
public static void main(String[] args) {
int s= f(12);
System.out.println("第12个数为：s="+s);
}
public static int f(int n){
if(n<=2){
return 1; //当a=1时返回值为1
}
int sum=f(n-1)+f(n-2);//求f(n)的值
return sum; //将值sum返回给f(n)
}
练习3： 1， 3， 5， 7， 9， 11 . 问前10个数的和
public static void main(String[] args) {
int sum=0;
int su=g(10);
while (su>=1){ //求前十个数的和
sum+=su;
su=su-2;
}
System.out.println("前10个数的和为：sum="+sum);
}
public static int g(int a){
int sum=0;
if(a==1){
return 1; //当a=1时返回值为1
}
int su=g(a-1)+2; //求g(a)的值
// System.out.println("这里su="+su);
return su;
}
练习4 ： 前5个阶乘之和 例如 5!+4!+3!+...1!
public static void main(String[] args) {
long sv=0;
int i=5; //定义要求的第几个阶乘
long d=h(i);
System.out.println("h="+d);
for(long j=i;j>=1;j--){ //求阶乘的和
sv=sv+h(j);
}
System.out.println("前5个阶乘之和为："+sv);
}
public static long h(long i){
if(i==1){
return 1; //当a=1时返回值为1
}
long sum=i*h(i-1);//求h(i)的阶乘
return sum;
}
练习5：定义一个函数，函数有一个整型参数n，
如果参数n为偶数时，调用函数求1/2+1/4+...+1/n,
如果参数n为奇数时，调用函数1/1+1/3+...+1/n
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int p=sc.nextInt();
double m= j(p);
System.out.println("m="+m);
}
public static double j(double n){
double su=0;
if(n%2==0){
if(n==2) {
return 0.5;
}
su=j(n-2)+1/n;
System.out.println("su="+su);
return su;
}else {
if(n==1) {
return 1;
}
su=j(n-2)+1/n;
//返回值当n=4时，su(4)=j(2)+j(4) 也就是 su(4)=1/2+1/4
//1.0/n:表示它本身；如，当n=4时它本身的值为1/n
//j(n-2):表是它前一个数的值；求和，相加，如n=4时，j(4)=1/2+1/4
//如n=6时，su(6)=sum(4)+1/6
return su;
}
}
练习6、 1/1+1/2+2/3+3/5+5/8.。。。前8个数之和。
public static void main(String[] args) {
double sum=0;
int z=8;
for(int i=z;i>0;i--){
int a=l(i); //分子
int b=sm(i); //分母
sum=sum+a*1.0/b; //double 型，所以返回值要为为：double型，所以：1.0/1
}
System.out.println("sum="+sum);
}
public static int l(int n){
if(n<=2){
return 1;
}
int h=l(n-1)+l(n-2); //求单个分子
return h;
}
public static int sm(int m){
if(m==1){
return 1;
}
if (m == 2) {
return 2;
}
int k=sm(m-1)+sm(m-2); //求单个分母
return k;
}