菜鸡的Java笔记 第二十五 wrapperClass 包装类

wrapperClass 包装类
        1.包装类的特点
        2.装箱与拆箱操作
        3.数据转型处理
        
    内容
        Object 类可以接收所有的引用数据类型，因为引用数据类型本质上就是对象
        但是这之中会出现一个新的问题基本数据类型不是对象
        所以发现在最初设计的过程之中，Object 类无法接收基本数据类型

基本数据类型和引用类型之间最大的差别在于：基本数据类型属于值传递，而引用类型属于内存空间传递，这是两个不同的概念
可是考虑到一切皆对象这样的设计概念，所以最好的做法是将基本数据类型做一个包装

        所以最早人们提出一点能不能将基本数据类型包装一下就采用如下的代码结构
        范例：最初的包装设计

class Int{// 定义一个只包装int类型的包装类
    private int num;//真正的基本数据类型的数据
    public Int(int num){//接收基本数据类型
        this,num = num;// 基本类型变为了包装类
    }
    public int intValue(){// 从包装类中取出基本数据类型
        return this.num;
    }
}
public class wrapperClass{
    public static void main(String args[]){
        Int x = new Int(10);// 将基本类型变为包装类
        Object obj = x;// 对象转型
        System.out.println(x.intValue()*x.intValue());// 取出内容才能够计算
    }
}

           
            现在发现如果所有的代码都是这样设计会存在以下问题：
                java有八种基本数据类型：需要自己编写这八个基本类型；
                基本数据类型包装类不能够直接参与数学计算
            正式因为有这样需求的提出（参数统一需求），所以从最早的JDK1.0开始就提供有了包装类，用户不需要进行包装类的设计了，
            而在JDK1.5之后有解决了包装类参与数学计算的问题
            java基本数据类型的包装类：byte(Byte),short(Short),int(Integer),long(Long),float(Float).double(Double),char(Character),boolean(Boolean)
            而这八种包装类也分为两种类型
                对象型（java.lang.Object 直接子类）： Character,Boolean;
                数值型（java.lang.Number 直接子类）： Byte,Short,Integer.Long Float,Double
            对于Number类可以发现其本质上是一个抽象类：
                public abstract class Number extends Object implements Serializable
            而后在这个Number类中提供有六个操作方法：
                从包装类取出 byte 数据： public byte byteValue();
                从包装类取出 int 数据： public abstract int intValue();
                从包装类取出 short 数据： public short shortValue();
                从包装类取出 long 数据： public abstract long longValue();
                从包装类取出 float 数据： public abstract float floatValue();
                从包装类取出 double 数据： public abstract double doubleValue();
            那么严格来讲这几个方法都属于拆箱方法

    装箱与拆箱操作
        对于基本数据类型与包装类之间的转换分为以下两个概念：
            装箱操作：将基本数据类型变为包装类，各个包装类的构造完成；
                Integer类的构造： public Integer(int value);
                Double类的构造： public Double(double value);
                Boolean类的构造： public Boolean(boolean value);
            拆箱操作：将包装类中的基本数据类型取出，如果是Object类型的包装类则每一个包装类中会有拆箱操作方法，
            而如果是Number 的包装类，所有的拆箱方法都在 Number类中定义完成了
                Number 父类里面就定义有拆箱操作的方法：？？？Value()方法
            
        范例：以 Integer与 int为例

            public class wrapperClass{
                public static void main(String args[]){
                    Integer x = new Integer(10);//装箱操作
                    int temp = x.intValue(); // 拆箱操作
                }
            }

           
        范例：以 Double 与 double 为例
           

public class wrapperClass{
                public static void main(String args[]){
                    Double x = new Double(10.0);//装箱操作
                    double temp = x.doubleValue(); // 拆箱操作
                }
            }

           
        范例：以 Boolean 与 boolean 为例
 

           public class wrapperClass{
                public static void main(String args[]){
                    Boolean x = new Boolean(true);//装箱操作
                    boolean temp = x.booleanValue(); // 拆箱操作
                }
            }

           
        所有的装箱与拆箱操作都是固定的操作模式，然而以上的代码是在JDK1.5之前采用的，现在不可能采用此方式了
        因为太麻烦了，所以从JDK1.5之后提供有自动装箱与拆箱的支持
        范例：以 Integer与 int为例

            public class wrapperClass{
                public static void main(String args[]){
                    Integer x = 100;//自动装箱为类操作
                    int y = x;
                    System.out.println(++ x * y);// 直接自动拆箱进行累加操作
                }
            }// 结果：10100            

           
        范例：以 Double 与 double 为例

            public class wrapperClass{
                public static void main(String args[]){
                    Double x = 100.1；
                    double y = x;
                    System.out.println(++ x * y);
                }
            }

           
        范例：以 Boolean 与 boolean 为例

            public class wrapperClass{
                public static void main(String args[]){
                    Boolean flag = true;
                    if(flag){ // 对象判断，自动拆箱
                        System.out.println("***********************");
                    }
                }
            }

           
        实际上有了这种自动装箱的机制存在，就可以使用Object 接收基本数据类型了
        范例：利用 Object 接收 int

            public class wrapperClass{
                public static void main(String args[]){
                    Object obj = 10; // 转换：10 自动装箱为 Integer,Integer 向上转型
                    int temp = (Integer)obj;// 向上转型为 Integer ,自动拆箱为int
                    System.out.println(++ x * y);// 直接自动拆箱进行累加操作
                }
            }

           
        结论：Object 无所不能，所有数据类型都可以接收，万能的很

    数据类型转换
        包装类本身有一个非常重要的功能，就是字符串转换为基本数据类型的操作
        在实际所有的开发之中，用户只要执行数据的输入操作，其类型就是String
        在包装类里面都提供有一些转换方法，以常用的几个类型为主：
            Integer类的方法： public static int parseInt(String s);
            Double类的方法： public static double parseDouble(String s);
            Boolean类的方法： public static boolean parseBoolean(String s);
        Character 类没有提供这样的方法，因为String类有一个charAt()方法，直接选0索引即可
        范例：以 Integer 为例

            public class wrapperClass{
                public static void main(String args[]){
                    String str = "100";// 字符串数字组成
                    int num = Integer.parseInt(str);// 将字符串转换为int
                    System.out.println(num * 2);
                }
            }

           
            但是此时有两点注意
                1.如果字符串要转换为数字，其必须由数字所组成
        范例：错误代码

            public class wrapperClass{
                public static void main(String args[]){
                    String str = "acb22";// 字符串数字组成
                    int num = Integer.parseInt(str);// 将字符串转换为int
                    System.out.println(num * 2);
                }
            }            

           
                2.关于比较的问题

            public class wrapperClass{
                public static void main(String args[]){
                    String str = "100";// 字符串数字组成
                    int num = Integer.parseInt(str);// 将字符串转换为int
                    Integer x1 = 100;
                    Integer x1 = new Integer(100);
                    System.out.println(x1 == num);
                    System.out.println(x1 == x2);(使用 extends 才是.....)
                }
            }/* 结果：
                true
                false

　　　　*/

               
        因为在实际的开发之中，包装类使用比较多，所以在进行“==”比较的时候，要使用 extends() 方法才是最保险的
        
        范例：以 Double 为例

            public class wrapperClass{
                public static void main(String args[]){
                    String str = "100.1";// 字符串数字组成
                    double num = Double.parseInt(str);// 将字符串转换为int
                    System.out.println(num * 2);
                }
            }

           
            在使用 parseDouble() 将字符串转换为 double 类型的时候，里面的组成可以是整数也可以是小数
                
        范例：以 Boolean为例    

            public class wrapperClass{
                public static void main(String args[]){
                    String str = "100";
　　　　　　　　　　　　// 字符串数字组成 如果是true 打印的是 * ,是 false 打印 #
                    boolean flag = Boolean.parseBoolean(str);  // false
                    if(flag){
                        System.out.println("***********************");
                    }else{
                        System.out.println("#####################");
                    }
                }
            }// 结果： #####################

               
            发现在使用 Boolean 类型操作的时候比较方便，即使给定的字符串内容不是 true 或者 false，其最终都会统一按照 false 来进行处理
        提示：String与基本数据类型的转换
            String 要变为基本数据类型：包装类中的 parse???()方法
            基本数据类型变为String呢？
                任何的数据类型使用“+”与String连接都会转换为String类型

            public class wrapperClass{
                public static void main(String args[]){
                    String str = "hello";// 字符串数字组成
                    System.out.println(str + 100); // hello 100
                }
            }

           
            本代码实际上进行一个字符串的连接操作，连接之后一定会产生垃圾
            在String类中有一组重载的valueOf() 方法：

                public class wrapperClass{
                    public static void main(String args[]){
                        String str = String.valueOf(100);// 字符串数字组成
                        System.out.println(str.length()); //
                    }
                }

           
            这样编写的好处是可以避免垃圾的产生
                
    总结
        1.自动装箱与拆箱的特点
        2.NNumber类的定义以及方法
        3.基本数据类型与String的转换