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

心已赠人 2024-03-22 11:13 60阅读 0赞

### 【大数据】学习笔记 ###

#### 文章目录 ####

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

![在这里插入图片描述][66dc748a9ac74cf28f448b25ef205084.png_pic_center]

#### 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}));//传入数组实参
        }
    }

![在这里插入图片描述][b85d153fd318478781a326baf87d774c.png_pic_center]

【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"));
        }
    }

![在这里插入图片描述][40fbf53299264b238818f1a3f7369a44.png_pic_center]

###### 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
        }
    }

![在这里插入图片描述][b2a16019c59941e0b0bb5c9b27af172f.png_pic_center]

【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
        }
    
    }

![在这里插入图片描述][21666ba901ab4f3691af1f64e28c5877.png_pic_center]

【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数组的元素
            //上面的代码，从头到尾，堆中只有一个数组，没有产生新数组，无论是排序还是遍历输出都是同一个数组
        }
    }

![在这里插入图片描述][933dd4cf489846f78e9b1be07981c421.png_pic_center]

【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
        }
    }

![在这里插入图片描述][f84b8ac8c8a341688e83dc8cb271bf96.png_pic_center]

[66dc748a9ac74cf28f448b25ef205084.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/2b065ba60eb84946ac7dbdcbdee3eed0.png
[b85d153fd318478781a326baf87d774c.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/8b71c1a401d84ef4adfdd083fd900b24.png
[40fbf53299264b238818f1a3f7369a44.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/bc9bd2da4bee4111a071841dfb93d388.png
[b2a16019c59941e0b0bb5c9b27af172f.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/be8bd38f8efe44eaa9f5dc663606f98d.png
[21666ba901ab4f3691af1f64e28c5877.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/d6f0f541fabc4f8e8b7170edeb2358b6.png
[933dd4cf489846f78e9b1be07981c421.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/8ecbd07177854e3daf6114f2e955f3c9.png
[f84b8ac8c8a341688e83dc8cb271bf96.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/6597a51cf47c4cddbaa6ba0394606e40.png