Java基础之包装类4月打卡day14

关于作者

• 作者介绍

🍓 博客主页：作者主页

🍓 简介：JAVA领域优质创作者🥇、一名在校大三学生🎓、在校期间参加各种省赛、国赛，斩获一系列荣誉🏆。

🍓 关注我：关注我学习资料、文档下载统统都有，每日定时更新文章，励志做一名JAVA资深程序猿👨‍💻。

包装类

在Java的设计之中，一直倡导一个原则：一切皆对象，这个原则本省有一个漏洞，基本数据类型不是对象，所以这个原则就出现了问题，那么如果说现在这个问题由我们来解决，该如何解决呢？

class MyInt{
    private int num;//基本类
    public MyInt(int num){
        this.num=num;
    }
    public int intValue(){
        return this.num;
    }
}
public class TestDemo6{
    public static void main(String args[]){
        Object obj = new MyInt(10);//子类自动变为Object父类对象
        MyInt temp = (MyInt) obj;//向下转型
        int result = temp.intValue();
        System.out.println(result*result);
    }
}

以上的操作是将基本类型变为了一个对象的形式进行操作了，但是这里面有一个问题：基本数值型数据是可以进行数学运算的，可是以上变为了类的形式，那么肯定无法直接计算了。以上的问题既然我们都想到方法解决，那么Java也一定早已解决，为此它专门提供了八种包装类：

byte(Byte),short(Short),int(Integer),long(Long),float(Float),double(Double),boolean(Boolean),char(Character);

而这八种包装类有分为两大阵营：

 数值型（Number子类）：Byte,Short,Integer(int),Float,Double,Long;
​
 对象型（Object子类）：Boolean,Character(char)。

可是对于Number的子类，就必须观察出Number类之中定义的方法：byteVlue()、intVlue()、doubleVlue()、shortVlue()、longVlue()、floatVlue()，就是从包装的类之中取得所包装的数值。

1、装箱与拆箱

在基本数据类型和包装类之间的转化之中分为两个重要概念：

 装箱操作：将基本数据类型变为包装类，称为装箱，包装类的构造方法。
​
 拆箱操作：将包装类变为基本数据类型，称为拆箱，Number类中的xxValue()方法。

以int和Integer为例

public class TestDemo{
    public static void main(String args[]){
        Integer var = new Integer(10);//装箱
        int result = var.intValue();//拆箱
        System.out.println(result*result);
    }
}

以double和Double为例

public class TestDemo{
    public static void main(String args[]){
        Double var = new Double(10.0);//装箱
        double result = var.doubleValue();//拆箱
        System.out.println(result*result);
    }
}

以上的操作实在JDK1.5之前所进行的必须的操作，但是到了JDK1.5之后，Java提供了自动装箱和自动拆箱的机制，并且包装类的对象可以自动的进行数学计算了。

自动装箱与拆箱

public class TestDemo{
    public static void main(String args[]){
        Integer var = 10;//自动装箱
        int result = var;//自动拆箱
        //可以直接利用包装类进行对象操作
        System.out.println(++var*result);//自动进行数学运算
    }
}

但是到此为止还有一个小问题，实际上这一问题之前已经见过。

public class TestDemo{
    public static void main(String args[]){
        Integer x = new Integer(10);//新空间
        Integer y = 10;//入池
        Integer z = 10;
        System.out.println(x==y);//false
        System.out.println(x==z);//false
        System.out.println(y==z);//ture
        System.out.println(x.equals(y));//ture
    }
}

使用包装类的时候还需要考虑equals()和==的区别。

使用int还是Integer?

• 在接收数据的时候，使用的一定都是int，而保存数据的时候一般使用Integer

• 以后编写的简单java类统一不要再去使用基本数据类型，全部换位包装类

2、字符串与基本数据类型的转换

包装类之中所提供的最大优点在于可以讲字符串变为制定的基本数据类型，下面列出几个操作：

 Integer类：public static int parseInt(String s);
​
 Double类：public static double parseDouble(String s);
​
 Boolean类：public static boolean parseboolean(String s;

但是character这个包装类之中，并没有提供一个类似的parseCharacter()，因为字符串String类之中提供了一个charAt()方法，可以取得制定索引的字符，而且一个字符的长度就是一位。

将字符串变为int

public class TestDemo{
    public static void main(String args[]){
        String str = "16";
        int result = Integer.parseInt(str);//String ——>int
        System.out.println(result*result);
    }
}

但是需要提醒的是，在执行这种转化的操作过程之中，字符串字符串中的全部内容必须由数字所组成，如果有一位内容不是数字，则在转化的过程之中讲出现如下的错误提示：NumbnerFormatException。

将字符串变为double

public class TestDemo{
    public static void main(String args[]){
        String str = "16.";
        double result = Double.parsedouble(str);//String ——>int
        System.out.println(result*result);
    }
}

将字符串变为boolean型数据

public class TestDemo{
    public static void main(String args[]){
        String str = "true";
        boolean result = Boolean.parseboolean(str);//String ——>int
        System.out.println(result);
    }
}

提示：在使用Boolean型包装类的时候，如果字符串之中的内容不是true或者是false，统一都按照false处理。

以上的操作是通过字符串变为一些基本类型的数据，但是反过来讲，基本数据类型如何变为字符串呢？

方式一：任何基本数据类型遇到了String之后都会变为String型数据；

public class TestDemo{
    public static void main(String args[]){
        int num = 100;
        String str = num+"";//int——>String //会产生垃圾
        System.out.println(str.length());
    }
}
//会有垃圾产生

方式二：利用String方法，public static String valueOf(数据类型 b)

public class BaoZhuangLei{
    public static void main(String args[]){
        int num = 100;
        String str =String.valueOf(num);//int——>String
        System.out.println(str.length());
    }
}

3、包的定义

在Java程序之中的包，主要的目的是可以将不同功能的文件进行分割，在之前的代码开发之中，所有的程序都保存在了同一个目录之中，这样一来所带来的问题：如果出现了同名的文件，那么会发生覆盖问题，因为在同一个目录之中不允许有重名的文件，而在不同的目录下可以有重名文件，所谓的包实际上指的就是文件夹。

package cn.mldn.demo;//定义包
public class Hello{
    public static void main(String args[]){
        System.out.println("Hello World");
    }
}
​

一旦定义完成之后，那么这个类的名字就成了“cn.mldn.demo.Hello”，即这既是完整的类名称，而在进行程序编译的时候也需要将*.class文件保存在包之中，于是为了方便开发，那么也就提供了一个打包的编译操作。

打包编译：javac -d . 类.java

-d:表示生成目录，根据package定义生成

-“.”:再当前目录下生成*.class

类.java:编译源程序代码

这个时候类的名字必须带上包的名称，所以执行类的时候：java cn.mldn.demo.Hello，也就是说完整类的名称就是“包.类”，而在所有的开发之中，没有包的类是绝对不存在的，只要是程序一定要有包。

4、包的导入

既然使用包可以将一个大型的程序拆分成不同的功能目录保存，那么这些不同的包之间也一定会存在包的导入问题，而导入包在程序之中使用import完成，下面通过一个程序进行演示。

//定义一个Message
package cn.mldn.util;//打包
class Massage{
    public String print(){
        return "Hello World";
    }
}

//定义另外一个类使用Message类
package cn.mldn.text;//打包
import cn.mldn.util.Message;//导入包
public class Text{
    public static void main(String args[]){
        Massage msg = new cn.mldn.util.Massage();
        System.out.println(msg.print());
    }
}   

这个时候上面的两个类应该是按照顺序编译：

 应该首先编译Message.java程序：javac –d . Message.java;
​
 再次编译Test.java程序：javac –d . Test.java，但是这个时候出现了一下的错误提示：

Text.java:5: 错误: Massage在cn.mldn.util中不是公共的; 无法从外部程序包中对其进行
访问
                Massage msg = new cn.mldn.util.Massage();
                ^

提示：关于public class 和class定义类的区别

 Public class：文件名和类名称保持一致，在一个*.java文件之中只能存在一个public class定义，如果一个类要想被外部包所访问必须定义为public；
​
 Class：文件名称可以和类名称不一致，在一个*.java之中可以同事存在多个class定义，并且编译完成之后会形成多个*.class文件，使用class定义的类只能够在一个包中访问，不同包之间无法访问。

package cn.mldn.util;//打包
public class Massage{
    public String print(){
        return "Hello World";
    }
}

但是同时也发现了一个问题，现在这些类在编译的时候要有顺序，实在很麻烦，为此在java之中专门提供了一个可以进行自动连编的操作，编译的时候使用*.java：javac –d . .java，将一个目录之中所有的.java文件进行编译。

 但是以上的代码还有一个小问题：程序在进行导入的时候使用了“包.类”的完整名称完成的，但是如果在一个程序之中要同时导入一个包的多个类的时候，那么分开去编写实在很麻烦，为此可以使用通配符“*”完成导入。

package cn.mldn.text;//打包
import cn.mldn.util.*;//导入包
public class Text{
    public static void main(String args[]){
        Massage msg = new cn.mldn.util.Massage();
        System.out.println(msg.print());
    }
}   

但是需要注意的是，在java之中使用“”或者是的单独导入，其从实际的操作性能上是没有任何区别的，因为即使使用了也表示导入所需要的类，不需要的不导入。

 可是在导入包的时候也会遇到一种比较麻烦的问题：会导入不同包的同名类，例如：对于Message类，现在在两个包中都有：cn.mldn.util cn.mldn.info

package cn.mldn.text;//打包
import cn.mldn.util.*;//导入包
import cn.mldn.info.*;//导入包
public class Text{
    public static void main(String args[]){
        Message msg = new cn.mldn.util.Message();
        System.out.println(msg.print());
    }
}
/*
Text.java:6: 错误: 对Message的引用不明确, cn.mldn.info中的类 cn.mldn.info.Messag
e和cn.mldn.util中的类 cn.mldn.util.Message都匹配
                Message msg = new cn.mldn.util.Message();
                ^
*/

由于某种需要，同时导入两个包，这个时候要使用Message类的时候必须加上类的全名。

package cn.mldn.text;//打包
import cn.mldn.util.*;//导入包
import cn.mldn.info.*;//导入包
public class Text{
    public static void main(String args[]){
        cn.mldn.util.Message msg = new cn.mldn.util.Message();
        System.out.println(msg.print());
    }
}