java多个方法事务 java中dosome方法

转载

架构师之光 2023-08-26 23:05:27

文章标签 java多个方法事务 javase System 包装类基本数据类型 文章分类 Java 后端开发

基本类型对应的8个包装类

1.8种包装类存在的意义

java中为8种数据类型又对应准备了8种包装类型。8种包装类属于引用数据类型，父类是Object。
为什么要提供8种包装类呢？
因为8种基本类型不够用

public class IntegerTest01 {
    public static void main(String[] args) {
        /*假设有需求：调用doSOme()方法的时候需要传一个数字进去，
        但是数字属于基本数据类型，而doSOme方法参数的类型是Object
        可见doSome方法无法接收基本数据类型的数字。怎么办?可以传一个数字对应的包装类进去。
        */
        //把100这个数字经过构造方法包装成对象
        MyInt myInt = new MyInt(100);
        //doSome方法虽然不能直接传100，但是可以传一个100对应的包装类型
        doSome(myInt);
    }
    public static void doSome(Object obj){
        System.out.println(obj);
    }
    //输出结果为：100
}

package se2.integer;

public class MyInt {
    int value;

    public MyInt() {}
    public MyInt(int value) {
        this.value = value;
    }
    //重写toString方法
    @Override
    public String toString() {
        return String.valueOf(value);
    }
}

2.8种基本数据类型对应的包装类型名是什么？

基本数据类型	包装类型
byte	java.lang.Byte（父类Number）
short	java.lang.Short（父类Number）
int	java.lang.Integer（父类Number）
long	java.lang.Long（父类Number）
float	java.lang.Float（父类Number）
double	java.lang.Double（父类Number）
boolean	java.lang.Boolean（父类Object）
char	java.lang.Character（父类Object）

以上8种包装类中，重点以java.lang.Integer为代表进行学习，其他的类型照葫芦画瓢就行了

3.装箱和拆箱的概念

Number是一个抽象类，无法实例化对象

Number类中有这样的方法：

byte byteValue()	以byte形式返回指定的数值
abstract double doubleValue()	以double形式返回指定的数值
abstract float floatValue()	以float形式返回指定的数值
abstract int intValue()	以int形式返回指定的数值
abstract long longValue()	以long形式返回指定的数值
short shortValue()	以short形式返回指定的数值

这些方法其实所有的数字包装类的子类都有，这些方法是负责拆箱的。

public class IntegerTest02 {
    public static void main(String[] args) {
        //123这个基本数据类型，进行构造方法的包装达到了：基本数据类型向引用类型的转换
        //基本数据类型（转换）-->引用数据类型（装箱）
        Integer i = new Integer(123);
        //将引用数据类型（转换）-->基本数据类型（拆箱）
        float f = i.floatValue();
        System.out.println(f);//123.0
        //将引用数据类型（转换）-->基本数据类型（拆箱）
        int retValue = i.intValue();
        System.out.println(retValue);//123
    }
}

4.自动装箱与自动拆箱

在JDk1.5（java5）之后，支持自动拆箱和自动装箱了

自动装箱：基本数据类型自动转换成包装类
自动拆箱：包装类自动转换成基本数据类型
有了自动拆箱之后，Number类中的方法就用不着了！

自动装箱和自动拆箱的好处：方便编程

package se2.integer;

public class IntegerTest05 {
    public static void main(String[] args) {
        //900是基本数据类型
        //x是包装类型
        //基本数据类型--（自动转换）-->包装类型：自动装箱
        Integer x = 900;
        System.out.println(x);//900

        //x是包装类型
        //y是基本数据类型
        //包装类型--（自动转换）-->基本数据类型：自动拆箱
        int y = x;
        System.out.println(y);//900

        //z是一个引用，是一个变量，z还是保存了一个对象的内存地址
        Integer z = 1000;//等同于：Integer z = new Integer(1000);
        //分析为什么没有报错呢？
        /**
         * +号两边要求是基本数据类型的数字，z是包装类，
         * 不属于基本数据类型，这里会自动拆箱，将z转换
         * 成基本数据类型
         */
        System.out.println(z + 1);

        Integer a = 1000;//Integer a = new Integer(1000);a是个引用，保存内存地址指向对象
        Integer b = 1000;//Integer b = new Integer(1000);b是个引用，保存内存地址指向对象
        //== 比较的是对象的内存地址，a和b两个引用中保存的对象内存地址不同
        //== 不会触发自动拆箱机制。（只有+-*/等运算的时候才会）
        System.out.println(a == b);//false
    }
}

扩展：

package se2.integer;
/*
这个题目是Integer非常重要的面试题
 */
public class IntegerTest06 {
    public static void main(String[] args) {

        Integer a = 128;
        Integer b = 128;
        System.out.println(a == b);//false
        /**
         * java中为了提高程序的执行效率，将-128到127之间所有的包装对象提前创建好，
         * 放到了一个方法区的“整数型常量池”当中了，目的是只要用这个区间的数据不需要
         * 再new了，直接从整数型常量池当中取出来。
         */
        //原理：x变量中保存的对象的内存地址和y变量中保存的对象的内存地址是一样的
        Integer x = 127;
        Integer y = 127;
        System.out.println(x == y);//true
    }
}

5.Integer的构造方法

关于Integer类的构造方法，有两个：

Integer(int)

Integer(String)

package se2.integer;

public class IntegerTest03 {
    public static void main(String[] args) {
        //java9之后不建议使用这个构造方法了
        //将数字100转换成Integer包装类型（int -->Integer）
        Integer x = new Integer(100);
        System.out.println(x);//100

        //将String类型的数字，转换成Integer包装类型（String -->Integer）
        Integer y = new Integer("123");
        System.out.println(y);//123

        //double --> Double
        Double d = new Double(1.23);
        System.out.println(d);//1.23
        //String --> DOuble
        Double e = new Double("3.14");
        System.out.println(e);//3.14
    }
}

通过访问包装类的常量，来获取最大值和最小值，如下

package se2.integer;

public class IntegerTest04 {
    public static void main(String[] args) {
        
        System.out.println("int的最大值：" + Integer.MAX_VALUE);
        System.out.println("int的最小值：" + Integer.MIN_VALUE);
        System.out.println("byte的最大值：" + Byte.MAX_VALUE);
        System.out.println("byte的最小值：" + Byte.MIN_VALUE);
        /**输出结果：
         * int的最大值：2147483647
         * int的最小值：-2147483648
         * byte的最大值：127
         * byte的最小值：-128
         */
    }
}

6.Integer的常用方法

package se2.integer;

public class IntegerTest07 {
    public static void main(String[] args) {
        //1手动装箱与自动装箱
        //手动装箱
        Integer x = new Integer(1000);
        //手动拆箱
        Integer y = x.intValue();
        System.out.println(y);//1000

        Integer a1 = new Integer("123");
        //编译的时候没问题，运行时呢？
        //不是一个数字可以包装成Interger吗？不能！运行时会出现异常！
        //java.lang.NumberFormatException（数字格式化异常）
        //Integer a2 = new Integer("阿波");

        //2重点方法
        //static int parseInt(String s)
        //静态方法，传参String，返回int
        /**
         * 为什么常用这个方法？原因如下
         * 网页上文本框中输入的100实际上是“100”字符串，后台数据库中
         * 要求存储100数字，此时java程序需要将“100”转换成100数字。
         */
        int retValue = Integer.parseInt("123");//String -转换->int
        System.out.println(retValue + 110);//233
        /*
        int retValue2 = Integer.parseInt("阿波");
        System.out.println(retValue2 + 100);
        //报错：java.lang.NumberFormatException: For input string: "阿波"
        */
        //照葫芦画瓢
        double retValue3 = Double.parseDouble("3.14");
        System.out.println(retValue3 + 1);//4.140000000000001(精度问题)

        float retValue4 = Float.parseFloat("1.0");
        System.out.println(retValue4 + 1);//2.0

        //以下内容作为了解，不需要掌握
        /**
         * static String toBinaryString(int i)
         * 静态的：将十进制转换成二进制字符串
         */
        String binaryString = Integer.toBinaryString(3);
        System.out.println(binaryString);//11（二进制字符串）

        /**
         * static String toHexString(int i)
         * 静态的：将十进制转换成十六进制的字符串
         */
        //十六进制：1 2 3 4 5 6 7 8 9 a b c d e f  10 11 12 13 14 15 16 17 18 19 1a...
        String hexString1 = Integer.toHexString(16);
        System.out.println(hexString1);//10

        String hexString2 = Integer.toHexString(17);
        System.out.println(hexString2);//11
        /**
         * static String toOctalString(int i)
         * 静态的：将十进制转换成八进制字符串
         */
        String octalString = Integer.toOctalString(8);
        System.out.println(octalString);//10

        /**
         * valueOf方法作为了解
         * static Integer valueOf(int i)
         * 静态的：int --> Integer
         */
        Integer i1 = Integer.valueOf(100);
        System.out.println(i1);//100

        /** static Integer valueOf(String s)
         * 静态的：String --> Integer
         */
        Integer i2 = Integer.valueOf("100");
        System.out.println(i2);//100
    }
}

7.String、int、Integer之间互相转换

package se2.integer;

public class IntegerTest08 {
    public static void main(String[] args) {
        //String --> int
        String s1 = "100";
        int i1 = Integer.parseInt(s1);
        System.out.println(i1 + 1);//101

        //int --> String
        String s2 = i1 + "";//i1还是100字符串
        System.out.println(s2 + 1);//1001

        //int --> Integer
        //自动装箱
        Integer x = 1000;

        //Integer --> int
        //自动拆箱
        int y = x;

        //String --> Integer
        Integer a = Integer.valueOf("123");

        //Integer --> String
        String b = String.valueOf(a);
    }
}

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。