java数值类型之间的转换以及相互运算后的类型

1、 数值转换

我们经常会遇到数值之间的一些转换，其中如下图所示（网络图片），给出了数值类型之间的合法转换。其中实心箭头表示两种类型按照箭头方向转换是不会丢失精度的，虚线箭头表示，两个数据类型按照箭头方向进行转换会丢失一定的精度。

2、两个不同类型的数值类型进行运算结果是哪种类型？

废话不说，直接上代码：

package main.com.lyf;

/**
 * @BelongsPackage: main.com.lyf
 * @ClassName: Test01
 * @CreateTime: 2019-10-24 
 * @Description:
 */
public class Test01 {
	// 获取数据的数据类型
    public String getType(Object o) {
        return o.getClass().getName().toString();
    }

    public static void main (String[] args) {
        Test01 t = new Test01();
        byte b = 1;
        short s = 1;
        float f = 1.2f;
        double d = 1.2;
        int i = 1;
        long l = 1L;
        char c = 'a';
        // float + double
        System.out.println("float + double的类型是："+ t.getType(f+d)+"\t ,计算结果是："+(f+d));
        // float + int
        System.out.println("float + int的类型是："+ t.getType(f+i)+"\t ,计算结果是："+(f+i));
        // float + long
        System.out.println("float + long的类型是："+ t.getType(f+l)+"\t ,计算结果是："+(f+l));
        // double + int
        System.out.println("double + int的类型是："+ t.getType(d+i)+"\t ,计算结果是："+(d+i));
        // double + long
        System.out.println("double + long的类型是："+ t.getType(d+l)+"\t ,计算结果是："+(d+l));
        // long + int
        System.out.println("long + int的类型是："+ t.getType(l+i)+"\t ,计算结果是："+(l+i));
        // byte + short
        System.out.println("byte + short的类型是："+ t.getType(b+s)+"\t ,计算结果是："+(b+s));
        // byte + float
        System.out.println("byte + float的类型是："+ t.getType(b+f)+"\t ,计算结果是："+(b+f));
        // byte + double
        System.out.println("byte + double的类型是："+ t.getType(b+d)+"\t ,计算结果是："+(b+d));
        // byte + int
        System.out.println("byte + int的类型是："+ t.getType(b+i)+"\t ,计算结果是："+(b+i));
        // byte + long
        System.out.println("byte + long的类型是："+ t.getType(b+l)+"\t ,计算结果是："+(b+l));
        // short + float
        System.out.println("short + float的类型是："+ t.getType(s+f)+"\t ,计算结果是："+(s+f));
        // short + double
        System.out.println("short + double的类型是："+ t.getType(s+d)+"\t ,计算结果是："+(s+d));
        // short + int
        System.out.println("short + int的类型是："+ t.getType(s+i)+"\t ,计算结果是："+(s+i));
        //short + long
        System.out.println("short + long的类型是："+ t.getType(s+l)+"\t ,计算结果是："+(s+l));
        // char + byte
        System.out.println("char + byte的类型是："+ t.getType(c+b)+"\t ,计算结果是："+(c+b));
        // char + short
        System.out.println("char + short的类型是："+ t.getType(c+s)+"\t ,计算结果是："+(c+s));
        // char + float
        System.out.println("char + float的类型是："+ t.getType(c+f)+"\t ,计算结果是："+(c+f));
        // char + double
        System.out.println("char + double的类型是："+ t.getType(c+d)+"\t ,计算结果是："+(c+d));
        // char + int
        System.out.println("char + int的类型是："+ t.getType(c+i)+"\t ,计算结果是："+(c+i));
        // char + long
        System.out.println("char + long的类型是："+ t.getType(c+l)+"\t ,计算结果是："+(c+l));

    }
}

运行结果：

float + double的类型是：java.lang.Double	 ,计算结果是：2.400000047683716
float + int的类型是：java.lang.Float	 ,计算结果是：2.2
float + long的类型是：java.lang.Float	 ,计算结果是：2.2
double + int的类型是：java.lang.Double	 ,计算结果是：2.2
double + long的类型是：java.lang.Double	 ,计算结果是：2.2
long + int的类型是：java.lang.Long	 ,计算结果是：2
byte + short的类型是：java.lang.Integer	 ,计算结果是：2
byte + float的类型是：java.lang.Float	 ,计算结果是：2.2
byte + double的类型是：java.lang.Double	 ,计算结果是：2.2
byte + int的类型是：java.lang.Integer	 ,计算结果是：2
byte + long的类型是：java.lang.Long	 ,计算结果是：2
short + float的类型是：java.lang.Float	 ,计算结果是：2.2
short + double的类型是：java.lang.Double	 ,计算结果是：2.2
short + int的类型是：java.lang.Integer	 ,计算结果是：2
short + long的类型是：java.lang.Long	 ,计算结果是：2
char + byte的类型是：java.lang.Integer	 ,计算结果是：98
char + short的类型是：java.lang.Integer	 ,计算结果是：98
char + float的类型是：java.lang.Float	 ,计算结果是：98.2
char + double的类型是：java.lang.Double	 ,计算结果是：98.2
char + int的类型是：java.lang.Integer	 ,计算结果是：98
char + long的类型是：java.lang.Long	 ,计算结果是：98

总结：通过上面的结果可以看出来，如果有double类型数据，则结果就是double类型其次如果有float类型则结果就是float类型，其次如果有long类型则结果就是long类型，其次如果有int类型则结果就是int类型，其次剩下的char、byte、short之间相互做运算都返回int类型。