java基础40 可变参数、自动装箱和自动拆箱

 一、可变参数

     可变参数是jdk1.5新特性

1.1、可变参数的格式

     数据类型...变量名

//                    数据类型...变量名
public static void sum(int...arr){

}

1.2、可变参数要注意的细节

    1.如果一个函数的形参上使用上可变参数之后，那么调用该方法的时候可以传递参数也可以不传递参数
    2.可变参数实际上是一个数组对象
    3.可变参数必须位于形参的最后一个参数
    4.一个函数最多只有一个可变参数，因为可变参数要位于形参的最后一个位置上

1.3、例子

方法1：

1 package com.dhb.pattern;
2
3 /**
4  * @author DSHORE / 2018-6-13
5  * 此方法是使用原始的方法
 6  */
7 //需求:定义一个函数做加法运算(函数要做多少个数据的加法功能？是不确定的)
8 public class Demo3 {
9     public static void main(String[] args) {
10         int[] arr = {1,2,5,6,7,9,10,16};
11         sum(arr);
12     }
13     public static void sum(int[] arr){
14         int sum=0;
15         for (int i : arr) {//增强for循环 遍历数组
16            sum+=i;
17         }
18         System.out.println(sum);//返回结果：56
19     }
20 }

方法2：

1 package com.dhb.pattern;
2
3 /**
4  * @author DSHORE / 2018-6-13
5  * 此方法使用的是可变参数
 6  */
7 //需求:定义一个函数做加法运算(函数要做多少个数据的加法功能？是不确定的)
8 public class Demo3 {
9     public static void main(String[] args) {
10         sum(1,2,6,7,8,16,20);
11     }
12     //                  形参类型...变量名
13     public static void sum(int...arr){//可变参数
14         int sum=0;
15         for (int i : arr) {
16            sum+=i;
17         }
18         System.out.println(sum);//返回结果：60
19     }
20 }

方法二的拓展

1 package com.dhb.pattern;
2
3 /**
4  * @author DSHORE / 2018-6-13
5  */
6 //需求:定义一个函数做加法运算(函数要做多少个数据的加法功能？是不确定的)
7 public class Demo3 {
8     public static void main(String[] args) {
9         sum("12",1,2,6,7,8,16,20);
10     }
11     //                            形参类型...变量名
12     public static void sum(String s,int...arr){//可变参数
13         int sum=0;
14         for (int i : arr) {
15            sum+=i;
16         }
17         System.out.println(sum);//返回结果：60
18     }
19 }
20 //说明：结果依然是60，String类型的“12”并没有参与加法运算   详细说明，请看上方的“可变参数注意细节”

二、自动装箱和自动拆箱

 八种基本数据类型          包装类型
整型：
        byte                     Byte
        short                    Short
        int                        Integer
        long                      Long
浮点型：
        float                      Float
        double                   Double
boolean(布尔型)：
        boolean                 Boolean
字符型：
        char                      Character

1 package com.dhb.pattern;
2
3 /**
4  * @author DSHORE / 2018-6-13
5  *
6  */
7 public class Demo4 {
8     public static void main(String[] args) {
9
10         //自动装箱:自动把java的基本数据类型转换为对象类型数据
11         int temp=10;//基本数据类型
12         Integer b=temp; //把temp存储的值赋给了b变量（b变量是Integer包装类型）
13         System.out.println(b);//返回结果：10
14
15         //自动拆箱：把引用数据类型的数据转为基本数据类型数据
16         Integer c=new Integer(13);
17         int d=c;
18         System.out.println(d);//返回结果：13
19
20     }
21 }

附录：

1 package com.dhb.pattern;
2
3 /**
4  * @author DSHORE / 2018-6-13
5  *
6  * jdk1.5新特性之-----自动装箱与自动拆箱
7  */
8 public class Demo4 {
9     public static void main(String[] args) {
10         String str="12";
11         //字符串转为int类型数据,可以把字符串转为对应的数字
12         int i=Integer.parseInt(str);
13         System.out.println(i);//返回结果：12
14
15         //把数字转为字符串
16         System.out.println("把整数转成对应的字符串："+Integer.toString(i));//返回结果：12  注：这个12是字符串，而不是整数
17
18         //把整数转为对应的进制类型形式
19         System.out.println("10的二进制："+Integer.toBinaryString(10));//返回结果：1010
20         System.out.println("10的十六进制："+Integer.toHexString(10));//返回结果：a
21
22         //可以把字符串当成对应的数据帮你进行数据转换
23         String data="10";
24         int a=Integer.parseInt(data,2);
25         System.out.println("a的值："+a);//返回结果：2
26
27         //自动装箱:自动把java的基本数据类型转换为对象类型数据
28         int temp=10;//基本数据类型
29         Integer b=temp; //把temp存储的值赋给了b变量（b变量是Integer包装类型）
30         System.out.println(b);//返回结果：10
31
32         //自动拆箱：把引用数据类型的数据转为基本数据类型数据
33         Integer c=new Integer(13);
34         int d=c;
35         System.out.println(d);//返回结果：13
36
37         Integer e=126;
38         Integer f=126;
39         System.out.println("同一个对象吗："+(e==f));//返回结果：true
40         Integer g=128;
41         Integer w=126;
42         System.out.println("同一个对象吗："+(g==w));//返回结果：false
43         /* 解析：Integer类内部维护了一个缓冲数组,该缓冲数组存储-128~127
44          *     这些数据在一个数组中,如果你获取的数据落入到这个范围之内的,那么就直接从缓冲区中获取对应的数据.
45          */
46     }
47 }