Java基础三（重载与值传递）

方法重载（overload）

    1.定义：在同一个类中，允许存在一个以上的同名方法，只要他们的参数或者参数个数类型不同即可
    “两同一不同：”同一个类、相同的方法
参数列表不同：参数个数不同，参数类型不同
    2.在通过对象调用方法时，如何确定某一个指定的方法
      方法名 -> 参数列表

 public class OverLoadTest {
    public static void main(String[] args){
        OverLoadTest test = new OverLoadTest();
        test.getSum(1, 2);
    }
    //如下四个方法构成重载
    public void getSum(int i, int j){
        System.out.println(1);
    }
    public void getSum(double i, double j){
        System.out.println(2);
    }
    public void getSum(String i, int j){
        System.out.println(3);
    }
    public void getSum(int i, String j){
        System.out.println(4);
    }
//    public int getSum(int i, int j){
//        return 0;
//    }

}

public class OverLoadExer {
    public void mOL(int i){
        System.out.println(i * i);
    }
    public void mOL(int i,int j){
        System.out.println(i * j);
    }
    public void mOL(String s){
        System.out.println(s);
    }
    public int max(int i, int j){
        return (i > j)? i:j;
    }
    public double max(double d1, double d2 ){
        return (d1 > d2)? d1:d2;
    }
    public double max(double d1, double d2,double d3 ){
        double max = (d1 > d2)? d1:d2;
        return (max > d3)?max:d3;
    }
}

变量赋值

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

public class ValueTransferTest {
    public static void main(String[] args){
        int m = 10;
        int n = m;
        System.out.println("**************基本数据类型**************");
        System.out.println("m = " + m + ", n = " + n);

        n = 20;

        System.out.println("m = " + m + ", n = " + n);

        System.out.println("**************引用数据类型**************");
        Order o1 = new Order();
        o1.orderId = 1001;

        Order o2 = o1;
        System.out.println("o1.orderId = " + o1.orderId + ", o2.orderId = " + o2.orderId);
        //o1.orderId = 1001, o2.orderId = 1001

        o2.orderId = 1002;
        System.out.println("o1.orderId = " + o1.orderId + ", o2.orderId = " + o2.orderId);
        //o1.orderId = 1002, o2.orderId = 1002
    }
}

class Order{
    int orderId;
}

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

    形参：方法定义时，声明的小括号内的参数
    实参：方法调用时，实际传递的数据
    1.值传递机制：
    如果参数是基本数据类型，此时赋值的是实参所保存的数据值
    如果参数是引用数据类型，此时实参赋值给形参的是实参所保存的数据的地址值

public class ValueTransferTest1 {
    public static void main(String[] args){
        int m = 10;
        int n = 20;
        System.out.println("m = " + m + ", n = " + n);
        //m = 10, n = 20

        ValueTransferTest1 test = new ValueTransferTest1();
        test.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("swap里边的" + "m = " + m + ", n = " + n);
        //swap里边的m = 20, n = 10
    }
}

public class ValueTransferTest2 {
    public static void main(String[] args){
        Data data = new Data();

        data.m = 10;
        data.n = 20;

        System.out.println("m = " + data.m + ", n = " + data.n);

        //交换m和n的值
//        int temp = data.m;
//        data.m = data.n;
//        data.n = temp;

        ValueTransferTest2 test = new ValueTransferTest2();
        //m = 10, n = 20

        test.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;
}

可变形参的方法

   具体使用：
   格式： 数据类型 … 变量名
   传入的参数可以是不限个
   可变形参的方法与本类中方法相同，形参不同可以构成
   可变形参的方法与本类中方法相同，形参类型也相同的数组之间不可以构成重载，二者不能共存

public class MethodArgsTest {
    public static void main(String[] args){
        MethodArgsTest test = new MethodArgsTest();
        test.show(12);
        test.show("hello");
        test.show("hello", "hello", "hello");
    }

    public void show(int i){
        System.out.println(1);
    }
    public void show(String  str){
        System.out.println("String");
    }
    public void show(String ... str){
        System.out.println("show...String");
    }
//    public void show(String[] str){
//        System.out.println("show...String");
//    }



}

递归调用

public class RecursionTest {
    public static void main(String[] args) {
        //计算1到100的所有数的和
        //方法一
        int sum = 0;
        for(int i = 1 ;i <= 100;i++){
            sum += i;
        }
        System.out.println(sum);
        //方法二
        RecursionTest test = new RecursionTest();
        int a = test.getSum(100);
        System.out.println(a);

        int b = test.getSum1(5);
        System.out.println(b);

        int c = test.f(10);
        System.out.println(c);

        int d = test.fib(5);
        System.out.println(d);


    }
    public int getSum(int n){
        if(n ==1 ){
            return 1;
        }else{
            return n + getSum(n - 1);
        }
    }

    public int getSum1(int n){
        if(n ==1 ){
            return 1;
        }else{
            return n * getSum(n - 1);
        }
    }
    //f0=1,f1=4,fn+2=2*fn+1 + fn,=->>f10
    public int f(int n){
        if (n == 0){
            return 1;
        }else if(n == 1){
            return 4;
        }else{
            return 2 * f(n - 1) + f(n - 2);

        }
    }
    //fibonacci数列
    public int fib(int n){
        if (n == 0)  {
            return 0;
        }
        if ((n == 1) || (n == 2)){
            return 1;
        }

        return fib(n - 1) + fib(n - 2);
    }
}