面向对象(二)1、方法重载（overload）定义：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数

1、方法重载（overload）

定义：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可

【两同一不同】：（和其他一切都无关）

【两同】：同一个类、同方法名；
【一不同】：参数列表不同：
- 参数个数不同；
- 参数类型不同；

public class JavaDemo {
    public void getSum(int i , int j){}
    public void geySum(double d1 , double d2){}
    public void geySum(String s , int i){}
    public void geySum(int i , String s){}
}

2、可变个数形参

格式：【数据类型...变量名】；

当调用可变个数形参方法时，传入的参数可以是0个或多个；

public class JavaDemo {
    public static void main(String[] args) {
        JavaDemo j = new JavaDemo();
        j.show();//String ... strs
        j.show("hello");//String ... strs
        j.show("hello" , "world");//String ... strs
    }

    public void show(String ... strs){
        System.out.println("String ... strs");
    }
}

可变个数形参方法与同类中方法名相同，形参不同的方法之间构成重载；
可变个数形参方法与同类中方法名相同，形参类型也相同的数组之间不构成重载，二者无法共存；
```
public void show(String ... strs){}
public void show(String[] strs){}
//实际上这两个方法是完全相同的
```

可变个数形参在方法的形参中，必须声明在末尾；

public void show(int i , String ... strs){}
public void show(String ... strs , int i){}//错误的

可变个数形参在方法的形参中，最多只能声明一个；

3、值传递

关于变量的赋值：
- 如果变量是基本数据类型，此时赋值的是变量所保存的数据值；
- 如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值；

方法形参的传递机制：值传递机制

形参：方法定义时，声明在小括号内的参数；
实参：方法调用时，实际传递给形参的数据；

针对基本数据类型（如果参数是基本数据类型，此时实参赋给形参的是实参真实存储的数据值）：

public class ValueTransferTest {
    public static void main(String[] args) {
        int m = 10;
        int n = 20;
        ValueTransferTest v = new ValueTransferTest();
        v.swap(m,n);
       // System.out.println("m="+m+"、"+"n="+n);//m=10、n=20
    }
	//数据交换
    public void swap(int m , int n){
        int temp = m;
        m = n;
        n = temp;
        System.out.println("m="+m+"、"+"n="+n);//m=20、n=10
    }
}

此时main方法中的输出语句输出的依然是未交换的m、n的值！以上写法是错误的！

针对引用数据类型（如果参数是引用数据类型，此时实参赋给形参的是实参存储数据的地址值）：

public class ValueTransferTest {
    public static void main(String[] args) {
       Data data = new Data();
       data.m = 10;
       data.n = 20;
       ValueTransferTest v = new ValueTransferTest();
       v.swap(data);
       System.out.println("m="+data.m+"、"+"n="+data.n);//m=20、n=10
    }

    public void swap(Data data){
       int temp = data.m;
       data.m = data.n;
       data.n = temp;
    }
}
class Data{
    int m;
    int n;
}

4、练习——参数传递

package com.wj;

public class RadiusTest{
    public static void main(String[] args) {
        Circle c = new Circle();
        PassObject p = new PassObject();
        p.printAreas(c,5);
        System.out.println("当前半径值为："+c.radius);
    }
}
class Circle {
    //圆的半径
   double radius;

   //返回圆的面积
    public double findArea(){
        return Math.PI * radius * radius;
    }
}
class PassObject{
    public void printAreas(Circle c , int time){
        System.out.println("radius"+"\t\t"+"Area");
        for (int i = 1 ; i <= time ; i++){
            c.radius = i;
            System.out.println(c.radius+"\t\t"+c.findArea());
        }
        c.radius = time + 1;
    }

}

5、递归方法

一个方法体内调用它自身
方法递归包含了一种隐式循环，它会重复执行某段代码，但这种重复执行无需循环控制
递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环！

范例：计算1~100之间所有自然数的和（计算乘积，将加号改为乘号即可）

public class RecursionTest {
    public static void main(String[] args) {
        RecursionTest r = new RecursionTest();
        System.out.println(r.getSum(100));
    }
    public int getSum(int n){
        if (n == 1){
            return 1;
        }else{
            return n + getSum(n-1);
        }
    }
}