【大数据】学习笔记 1 Java SE 第5章面向对象基础(上) 5.5 参数问题-蒲公英云

【大数据】学习笔记

文章目录

- 【大数据】学习笔记
- - 1 Java SE
  - - 第5章面向对象基础(上)
    - - 5.5 参数问题
      - 5.5.1 特殊参数之一：可变参数
        5.5.2 方法的参数传递机制

在这里插入图片描述

1 Java SE

第5章面向对象基础(上)

5.5 参数问题

5.5.1 特殊参数之一：可变参数

在JDK1.5之后，当定义一个方法时，形参的类型可以确定，但是形参的个数不确定，那么可以考虑使用可变参数。可变参数的格式：

【修饰符】 返回值类型 方法名(【非可变参数部分的形参列表,】参数类型... 形参名){  }

可变参数的特点和要求：

（1）一个方法最多只能有一个可变参数

（2）如果一个方法包含可变参数，那么可变参数必须是形参列表的最后一个

（3）在声明它的方法中，可变参数当成数组使用

（4）其实这个书写“≈”

【修饰符】 返回值类型 方法名(【非可变参数部分的形参列表,】参数类型[] 形参名){  }

只是后面这种定义，在调用时必须传递数组，而前者更灵活，既可以传递数组，又可以直接传递数组的元素，这样更灵活了。

【1】方法只有可变参数

案例：求n个整数的和

package com.dingjiaxiong.test05;
/**
 * @Projectname: BigDataStudy
 * @Classname: NumberTools
 * @Author: Ding Jiaxiong
 * @Date:2023/4/24 16:10
 */
public class NumberTools {
    int total(int[] nums) {
        int he = 0;
        for (int i = 0; i < nums.length; i++) {
            he += nums[i];
        }
        return he;
    }
    int sum(int... nums) {
        int he = 0;
        for (int i = 0; i < nums.length; i++) {
            he += nums[i];
        }
        return he;
    }
}

测试类：

package com.dingjiaxiong.test05;
/**
 * @Projectname: BigDataStudy
 * @Classname: TestVarParam
 * @Author: Ding Jiaxiong
 * @Date:2023/4/24 16:11
 */
public class TestVarParam {
    public static void main(String[] args) {
        NumberTools tools = new NumberTools();
        System.out.println(tools.sum());//0个实参
        System.out.println(tools.sum(5));//1个实参
        System.out.println(tools.sum(5, 6, 2, 4));//4个实参
        System.out.println(tools.sum(new int[]{
    5, 6, 2, 4}));//传入数组实参
        System.out.println("------------------------------------");
        System.out.println(tools.total(new int[]{
    }));//0个元素的数组
        System.out.println(tools.total(new int[]{
    5}));//1个元素的数组
        System.out.println(tools.total(new int[]{
    5, 6, 2, 4}));//传入数组实参
    }
}

在这里插入图片描述

【2】方法包含非可变参数和可变参数

非可变参数部分必须传入对应类型和个数的实参；
可变参数部分按照可变参数的规则传入0~n个对应类型的实参或传入1个对应类型的数组实参；

案例：

n个字符串进行拼接，每一个字符串之间使用某字符进行分割，如果没有传入字符串，那么返回空字符串””

package com.dingjiaxiong.test05;
/**
 * @Projectname: BigDataStudy
 * @Classname: StringTools
 * @Author: Ding Jiaxiong
 * @Date:2023/4/24 16:12
 */
public class StringTools {
    String concat(char seperator, String... args) {
        String str = "";
        for (int i = 0; i < args.length; i++) {
            if (i == 0) {
                str += args[i];
            } else {
                str += seperator + args[i];
            }
        }
        return str;
    }
}

测试类：

package com.dingjiaxiong.test05;
/**
 * @Projectname: BigDataStudy
 * @Classname: StringToolsTest
 * @Author: Ding Jiaxiong
 * @Date:2023/4/24 16:13
 */
public class StringToolsTest {
    public static void main(String[] args) {
        StringTools tools = new StringTools();
        System.out.println(tools.concat('-'));
        System.out.println(tools.concat('-', "hello"));
        System.out.println(tools.concat('-', "hello", "world"));
        System.out.println(tools.concat('-', "hello", "world", "java"));
    }
}

在这里插入图片描述

5.5.2 方法的参数传递机制

方法的参数传递机制：实参给形参赋值，那么反过来形参会影响实参吗？

方法的形参是基本数据类型时，形参值的改变不会影响实参；
方法的形参是引用数据类型时，形参地址值的改变不会影响实参，但是形参地址值里面的数据的改变会影响实参，例如，修改数组元素的值，或修改对象的属性值。
- 注意：String、Integer等特殊类型容易错

【1】形参是基本数据类型

案例：编写方法，交换两个整型变量的值

package com.dingjiaxiong.test05.param;
/**
 * @Projectname: BigDataStudy
 * @Classname: PrimitiveTypeParam
 * @Author: Ding Jiaxiong
 * @Date:2023/4/24 16:15
 */
public class PrimitiveTypeParam {
    void swap(int a, int b) {
    //交换两个形参的值
        int temp = a;
        a = b;
        b = temp;
    }
    public static void main(String[] args) {
        PrimitiveTypeParam tools = new PrimitiveTypeParam();
        int x = 1;
        int y = 2;
        System.out.println("交换之前：x = " + x + ",y = " + y);//1,2
        tools.swap(x, y);//实参x,y是基本数据类型，给形参的是数据的“副本”，调用完之后，x与y的值不变
        System.out.println("交换之后：x = " + x + ",y = " + y);//1,2
    }
}

在这里插入图片描述

【2】形参是引用数据类型

package com.dingjiaxiong.test05.param;
/**
 * @Projectname: BigDataStudy
 * @Classname: MyData
 * @Author: Ding Jiaxiong
 * @Date:2023/4/24 16:16
 */
public class MyData {
    int x;
    int y;
}
package com.dingjiaxiong.test05.param;
/**
 * @Projectname: BigDataStudy
 * @Classname: ReferenceTypeParam
 * @Author: Ding Jiaxiong
 * @Date:2023/4/24 16:16
 */
public class ReferenceTypeParam {
    void swap(MyData my) {
    //形参my是引用数据类型，接收的是对象的地址值，形参my和实参data指向同一个对象
        //里面交换了对象的两个实例变量的值
        int temp = my.x;
        my.x = my.y;
        my.y = temp;
    }
    public static void main(String[] args) {
        ReferenceTypeParam tools = new ReferenceTypeParam();
        MyData data = new MyData();
        data.x = 1;
        data.y = 2;
        System.out.println("交换之前：x = " + data.x + ",y = " + data.y);//1,2
        tools.swap(data);//实参是data，给形参my的是对象的地址值，调用完之后，x与y的值交换
        System.out.println("交换之后：x = " + data.x + ",y = " + data.y);//2,1
    }
}

在这里插入图片描述

【3】形参是数组

package com.dingjiaxiong.test05.param;
/**
 * @Projectname: BigDataStudy
 * @Classname: ArrayTypeParam
 * @Author: Ding Jiaxiong
 * @Date:2023/4/24 16:17
 */
public class ArrayTypeParam {
    void sort(int[] arr) {
    //给数组排序，修改了数组元素的顺序，这里对arr数组进行排序，就相当于对nums数组进行排序
        for (int i = 1; i < arr.length; i++) {
            for (int j = 0; j < arr.length - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }
    void iterate(int[] arr) {
    //输出数组的元素，元素之间使用空格分隔，元素打印完之后换行
        //这个方法没有修改元素的值
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }
    public static void main(String[] args) {
        ArrayTypeParam tools = new ArrayTypeParam();
        int[] nums = {
    4, 3, 1, 6, 7};
        System.out.println("排序之前：");
        tools.iterate(nums);//实参nums把数组的首地址给形参arr，这个调用相当于输出nums数组的元素
        //对数组的元素值没有影响
        tools.sort(nums);//对nums数组进行排序
        System.out.println("排序之后：");
        tools.iterate(nums);//输出nums数组的元素
        //上面的代码，从头到尾，堆中只有一个数组，没有产生新数组，无论是排序还是遍历输出都是同一个数组
    }
}

在这里插入图片描述

【4】形参指向新对象

package com.dingjiaxiong.test05.param;
/**
 * @Projectname: BigDataStudy
 * @Classname: AssignNewObjectToFormalParam
 * @Author: Ding Jiaxiong
 * @Date:2023/4/24 16:19
 */
public class AssignNewObjectToFormalParam {
    void swap(MyData my) {
        my = new MyData(); //这里让my形参指向了新对象，此时堆中有两个MyData对象，和main中的data对象无关
        int temp = my.x;
        my.x = my.y;
        my.y = temp;
    }
    public static void main(String[] args) {
        //创建这个对象的目的是为了调用swap方法
        AssignNewObjectToFormalParam tools = new AssignNewObjectToFormalParam();
        MyData data = new MyData();
        data.x = 1;
        data.y = 2;
        System.out.println("交换之前：x = " + data.x + ",y = " + data.y);//1,2
        tools.swap(data);//调用完之后，x与y的值交换？
        System.out.println("交换之后：x = " + data.x + ",y = " + data.y);//1,2
    }
}