Java基础进阶 基本类型包装类

1、基本类型包装类(掌握)

1.1、基本类型包装类介绍

场景：通过文本框获得用户输入的数字数据，因为文本框里面是书写文本数据的，所以后台得到的都是字符串。如果想要对字符串中的数字进行运算，必须将字符串转换成数字。
怎么解决上述出现的问题呢？
Java中提供了相应的解决问题的对象。
基本数据类型包装类：Java将基本数据类型值封装成了对象。
封装成对象有什么好处？
可以提供更多操作基本数据的功能。
java语言属于一种面向对象的语言，会把真实存在的事物或信息都会进行描述并封装为类。
在java中存在8种基本数据类型，而java语言也把这8种基本数据类型进行了封装。称为：包装类。
学习Java语法基础的时候，我们知道Java中有8种基本数据类型，这些数据类型可以在内存中开辟出对应类型的空间，然后可以保存对应类型的数据。
8种基本数据类型，它们仅仅只能规定空间的类型，而我们不能使用面向对象的方式去使用8种基本类型创建对象(newint();不能这样去创建基本类型的对象)。
由于8种基本类型不能像类类型一样去new对象，于是Java就对每种基本类型给出了一个对应的类类型。

而java语言也把这8种基本数据类型进行了封装。称为：包装类。
8种基本类型： byte short int long float double char boolean
对应的包装类型：Byte Short Integer Long Float Double Character Boolean

我们就可以使用这8种基本类型对应的类类型操作基本类型。
而这8个对应的包装类型，都在java.lang包下。

2.2、基本类型包装类演示

为什么要使用包装类呢？
8种基本类型的数据只能：赋值、运算、取值。
把基本类型进行封装后，就可以有更多的功能来操作基本类型数据。
基本类型包装类，它们包装的就是自己对应的某个基本类型。这样我们就可以使用包装类对象操作基本类型数据。

1.png

说明：字段摘要就是这个类中的成员变量。
所有的基本类型包装类中都有构造函数，可以把自己对应的基本类型的值，变成对应的包装类型对象中存放的那个数据。

2.png

package cn.xuexi.b_baozhuang_demo;
/*
 * 包装类讲解
 */
public class IntegerDemo {
    public static void main(String[] args) {
        //打印整数最大值和最小值
        System.out.println(Integer.MAX_VALUE);//最大值
        System.out.println(Integer.MIN_VALUE);//最小值
        //使用构造函数获取包装类对象
        //要求指定的字符串是数字字符串，否则会抛NumberFormatException异常
        Integer i = new Integer("123");
        //打印i的值
        System.out.println(i);
        //将十进制分别转换为其他进制
        System.out.println(Integer.toBinaryString(60));//二进制
        System.out.println(Integer.toOctalString(60));//八进制
        System.out.println(Integer.toHexString(60));//十六进制
    }
}

基本类型包装类：
把基本类型的数据包装成对象，然后提供更多的函数可以完成对基本数据的操作。

2.3、基本类型数据和包装类之间转换(掌握)

学习基本类型包装类：
1、把基本类型怎么转成对应的包装类型
2、把包装类型怎么转成基本类型
3、包装类型和字符串之间的转换
4、基本数据和字符串之间的转换

把基本类型怎么转成对应的包装类型：
1、可以通过对应的包装类的构造函数完成。

3.png

2、包装类中提供的静态函数：

4.png

需求：
1）定义一个DoubleDemo类，在这个类中定义一个double类型的变量d并赋值为123.12；
2）通过构造函数Double()将d转换为对应的包装类型d1，打印d1的值；
3）也可以使用Double类名调用valueOf()函数将变量d转换为包装类型d2，打印d2；

package cn.xuexi.b_baozhuang_demo;
public class DoubleDemo {
    public static void main(String[] args) {
        //定义一个double类型的数据
        double d=123.12;
        //1.通过构造函数把基本数据类型转换为对应的包装类型
        Double d1 = new Double(d);
        System.out.println(d1);
        //2.使用包装类中的静态方法来完成
        Double d2 = Double.valueOf(d);
        System.out.println(d2);
    }
}

把包装类型怎么转成基本类型
只能使用包装类中提供的函数。
xxxxValue方法。可以把对应的包装类型转成基本类型数据

5.png

2.4、字符串和基本类型数据、包装类型转换

包装类和字符串之间的转换
1、包装类转成字符串：
使用包装类中的toString方法完成

6.png

2、字符串转成包装类：
a) 可以通过包装类的构造函数完成。

7.png

b) 使用包装类中的valueOf方法

8.png

基本类型转字符串
1、可以直接使用+号
2、使用String类中的valueOf

9.png

3、使用对应的包装类中重载的toString方法

10.png
11.png

字符串转基本数据类型(开发中经常用)
字符串转成基本类型使用包装类中的parseXxxx方法。

12.png 13.png

注意：
1）后期学习中遇到和parse相关的函数，都是把字符串解析成其他的数据。
2）使用parseXxxx方法把一个字符串转成基本数据类型的时候，前提是这个字符串一定能够被转成对应的基本类型，否则会发生NumberFormatException异常。
根据查看API我们得知，如果转换不了会发生异常，所以在开发中如果使用上述方法将字符串转换为基本数据类型，需要对转换的代码进行捕获异常处理。

14.png
15.png

2.5、jdk5的自动装箱和拆箱
jdk5之前，需要把基本类型赋值给对应的包装类型，需要使用包装类型的构造函数，或者valueOf方法完成。
sun公司发现这样写比较麻烦，于是在在JDK5后给出了自动装箱的机制：
自动装箱：可以直接把一个基本类型的数据赋值给自己对应的包装类型。
自动拆箱：可以直接把一个包装类型的数据赋值给自己对应的基本类型。

package cn.xuexi.b_baozhuang_demo;
/*
 * 自动装箱和拆箱
 */
public class Demo1 {
    public static void main(String[] args) {
        //定义一个int类型数据
        int x=123;
        //使用jdk5以前办法将基本数据x变成包装类型
        Integer i = new Integer(x);
        Integer i1 = Integer.valueOf(x);
        //jdk5自动装箱
        //先把int类型数据x包装成Integer对象，然后把对象的内存地址放到i2变量中
        //在底层其实就是执行Integer.valueOf(x)这句话
        Integer i2=x;
        //jdk5的自动拆箱
        int z=i.intValue(); 
        //根据i引用变量空间中的地址找到对应的基本数据类型，保存在y变量空间中
        int y=i;
    }
}

说明：
1）Integer i2=x;

          先把int类型数据x包装成Integer对象，然后把对象的内存地址放到i2变量中，
          在底层其实就是执行Integer.valueOf(x)这句话。

2）int y = i;
根据i引用变量空间中的地址找到对应的基本数据类型，保存在y变量空间中。
在底层其实就是执行i.intValue()这句话。

3、JDK5的特性

3.1、静态导入(了解)

当我们在程序中需要使用某个类的时候，如果这个类不在当前的包中，通常情况下，我们需要导入这个类。
如果我们要使用当前这个类中的函数或属性都是静态的，这时可以在导入包的时候把这些静态的内容提前导入进来。
静态导入：在程序中，会遇到一些静态的方法、静态变量，当要使用静态成员时，就需要使用类名访问。而使用了静态导入后，就可以在书写上省略类名

静态导入的格式：
import static 包名.静态类.静态成员;

16.png

3.2、可变参数

需求：计算两个数值相加
计算三个数值相加
计算四个数值相加

17.png

使用以上方案解决，存在：程序的扩展性差的问题（如果再有一个计算5个值相加的功能，还要再书写一个函数）

现象：有时定义函数的时候，需要根据用户传递的参数的个数来决定到底我们定义函数上参数的个数。而不是自己直接在函数上就把参数的个数写死。这种问题就可以使用可变参数来解决。
可变参数：它主要针对的是程序员定义函数的时候，参数列表而言。
格式：修饰符 返回值类型 函数名( 可变参数 ){
}
可变参数：参数类型…变量名
说明：其实可变参数上定义的变量名就是一个数组名，我们在函数中就可以以数组的方式操作传递进来的所有数据，在这里相当于对数组进行求和。

/*
 * 可变参数讲解
 * 需求：计算两个数值相加
      计算三个数值相加
      计算四个数值相加
 */
public class Demo3 {

    public static void main(String[] args) {
        //调用自定义函数计算和值
        int sum=add(1,7);
        int sum1=add(1,7,4);
        int sum2=add(1,7,8,9);
        System.out.println(sum);
        System.out.println(sum1);
        System.out.println(sum2);
    }
    //使用可变参数可以接收不确定个数的数据
    public static int add(int ... num) {
        /*
         * 其实可变参数上定义的变量名就是一个数组名
         * 我们在函数中就可以以数组的方式操作传递进来的所有数据
         * 在这里相当于对数组进行求和
         */
        //定义一个变量接收数组中所有数据的和
        int sum=0;
        for (int i = 0; i < num.length; i++) {
            sum=sum+num[i];
        }
        return sum;
    }
    /*public static int add(int i, int j, int k, int l) {
        // TODO Auto-generated method stub
        return i+j+k+l;
    }*/

    /*public static int add(int i, int j, int k) {
        // TODO Auto-generated method stub
        return i+j+k;
    }*/

    /*public static int add(int i, int j) {
        // TODO Auto-generated method stub
        return i+j;
    }*/
}

结论：可变参数的底层其实还是使用数组。
在使用可变参数时，需要注意两个地方：
1）当函数中除了有可变参数外，还需要其它的参数时，必须把可变参数书写在函数中参数列表的最后面。

18.png

说明：因为第一个参数是可变参数，可以接收传递过来的所有参数，第二个参数就变得没有意义了。

错误： 19.png 正确： 20.png

2）在一个类中，如果已经存在了带有可变参数的函数，该类中就不能再存在另一个相同名称的带有数组参数的函数（参数列表不相同可以同时存在，以重载的方式存在）。

21.png

3.3、foreach循环(掌握)

foreach循环，也称为高级for循环或者叫做增强for循环。它可以简化普通的for循环。foreach 不能完全代替普通的for循环。
普通for循环的格式：
for( 循环初始化; 循环条件 ; 修改循环条件 ){
循环体
}

foreach循环：
for( 数组或集合中元素的类型 变量名 : 数组名或集合名 ){
//变量名所指的空间中，保存的是从数组或者集合中取出的数据
}

举例：

定义int类型的数组：
int[] arr={-1,4,0,79};
for(  int  x  :  arr  ){
//变量名x所指的空间中，保存的是从数组或者集合中取出的数据
} 

foreach循环它仅仅只能用来完成遍历，不能对操作的数组或集合中的数据进行修改操作。

22.png

注意：高级for循环只能用在遍历数组或者集合上。不能对数组或者集合中的数据进行修改。

4、其他常用类介绍

4.1、System类(掌握)

23.png

通过查阅API，可以得到：

1）System类，它是描述和系统相关的信息的，并且是一个最终的类。System类不能被继承。
2）System类不能创建对象。
3）System类中的成员全部都是静态的。

24.png 25.png

System类中的常用方法：
1、currentTimeMilllis()方法的作用：

26.png

1）获取当前系统时间的毫秒值。
2）在开发中，用来计算程序中功能的执行时间。

27.png

2、 System.exit(0);终止JVM运行 （开发中不建议使用）；

28.png

3、重要

29.png

说明：
1）getProperties()表示获取所有的系统属性信息；
说明：jvm虚拟机安装在了不同的平台上，比如Windows平台，jvm通常会获取Windows自身的一些信息 来为Java程序提供方便，因为程序最终要基于jvm虚拟机跑在windows平台上。所以，对于Java程 序而言必须得需要了解下Windows下都有哪些东西，因为Linux和Windows系统平台是不一样的。
而getProperties()就能获取到当前系统的一些相关的信息，这些信息有些是我们能够用到的，而且很实 用。

需求：获取系统中所有的属性信息。
代码如下所示：

30.png

上述函数是获取系统中所有的属性信息，那么我要想获取指定的信息，该怎么办呢？
比如：我想获得当前操作系统的用户的账户名称。这时可以使用如下函数：

2）getProperty(Stringkey) 表示根据系统属性信息的名称获取相应的信息；
其实就是根据参数中的key获取对应的value值，这个key可以理解为变量名，然获取变量值。

代码如下所示：

31.png

需求：实现跨平台换行。
比如将一个字符串 “hello我的世界” 使用输出语句输出到控制台上，但是要求这两个字符串换行输出，即
输出结果应该是：
hello
上海上海
分析：我们都知道在windows系统中换行符号是 \r\n ，只不过在eclipse控制台中也支持 \n 。 但是在windows系统中的很多软件中，比如记事本只支持 \r\n ，不支持 \n 。但是这只是在windows系统中，在其他的系统中不能被识别。
所以得出一个结论：原来在不同的操作系统中，换行符是不一样的。
那么要想在任何系统中都实现换行，怎么办呢？
在Java中的System类中提供了一个函数就是getProperty(String key) ，然后line.separator作为参数进行获取当前系统中的换行符。
代码如下所示：

32.png

说明：上面的程序拿到任何的系统中都可以实现跨平台了。
总结：找和系统相关的就要使用System类。

4.2、Math类

Math类：用来描述和数学相关的一些信息。Math类中方法全部都是静态方法。

33 .png

说明：
1）Math类不能有子类；
2）Math类不能被创建对象；
Math类中常用的函数：
1）abs()：返回一个数的绝对值；
2）ceil()：返回比指定数大的最小整数，返回值类型是double；
3）floor()：返回比指定数小的最大整数，返回值类型是double；
4）round()：返回四舍五入的数，返回值类型是int；
5）random()：生成大于等于 0.0 且小于 1.0 的随机 double类型的值

/*
 * Math类的演示
 */
public class MathDemo {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        System.out.println(Math.E);
        System.out.println(Math.PI);
        System.out.println(Math.abs(-3));//返回一个数的绝对值
        System.out.println(Math.ceil(4.123));//返回比指定数大的最小整数
        System.out.println(Math.floor(4.567));//返回比指定数小的最大整数
        System.out.println(Math.round(4.367));//返回四舍五入的数
        System.out.println(Math.random());//生成大于等于 0.0 且小于 1.0 的随机 double类型的值。
    }
}

4.3、Random类(理解)

34.jpg

Random类可以帮助我们产生一个随机数。

35.png

Random类中的函数代码演示：

/*
 * Random类说明
 */
public class RandomDemo {
    public static void main(String[] args) {
        //创建Random类的对象
        Random r=new Random();
        //函数演示
        System.out.println(r.nextInt());//生成一个在int范围之内的随机数
        System.out.println(r.nextInt(100));//生成一个大于等于零小于100之间的随机数
    }
}