Java中的类型转换

​​​​目录

​​​​​​

1、基本数据类型的类型转换

1. 整数运算的默认类型

2. 浮点数运算的默认类型

3. 混合运算的默认类型

4. 常量表达式中的类型

5、扩展赋值运算符:

2、向上转型与向下转型

向上转型

向下转型

---

1、基本数据类型的类型转换

在Java中，当基本数据类型进行运算时，编译器会按照一定的规则处理操作数，并且在某些情况下会发生类型转换。以下是基本类型进行运算时的默认类型规则和注意事项：

1. 整数运算的默认类型

当两个整数类型（byte, short, char, int, long）进行运算时，默认情况下：

• byte, short, char: 这些类型在运算时会先转换为int类型，然后进行运算。
• int: 默认的整数运算类型。如果参与运算的都是int类型，那么结果也是int类型。
• long: 如果有一个操作数是long类型，那么所有的整数类型操作数都会提升为long，结果类型也为long。

示例：

byte a = 10;
byte b = 20;
int result = a + b; // a 和 b 被提升为 int，结果也是 int

short s1 = 30;
short s2 = 40;
int result2 = s1 + s2; // s1 和 s2 被提升为 int，结果也是 int

short s3 = 0;
char c = 'a';
int result4 = s3 + c; // s3 和 c 被 提升为 int ，结果为97

int i = 100;
long l = 200L;
long result3 = i + l; // i 被提升为 long，结果也是 long

在上面的例子中，byte和short类型的变量在运算时被提升为int，并且运算结果也是int类型。char和short类型的变量在运算时被提升为int，结果也为int。当参与运算的操作数中有long类型时，所有操作数都会被提升为long，结果也为long。

---

2. 浮点数运算的默认类型

当涉及到浮点数类型（float, double）时：

• float: 如果所有操作数都是float类型，那么结果也是float。
• double: 默认的浮点数运算类型。如果有一个操作数是double类型，那么所有的浮点数操作数都会提升为double，结果类型也为double。

示例：

float f1 = 5.5f;
float f2 = 6.5f;
float result4 = f1 + f2; // 结果是 float

double d1 = 7.5;
double d2 = 8.5;
double result5 = d1 + d2; // 结果是 double

float f3 = 2.5f;
double d3 = 4.5;
double result6 = f3 + d3; // f3 被提升为 double，结果也是 double

在这个例子中，float类型的变量在运算时保持为float，除非有double类型的操作数出现，此时所有的操作数都会被提升为double，结果也是double。

---

3. 混合运算的默认类型

当整数类型和浮点类型混合运算时：

• 如果有一个操作数是浮点数类型（float或double），那么整数类型操作数会被提升为浮点数类型，并且结果类型为浮点数类型（float或double）。

示例：

int i1 = 10;
float f4 = 2.5f;
float result7 = i1 + f4; // i1 被提升为 float，结果也是 float

long l2 = 100L;
double d4 = 3.5;
double result8 = l2 + d4; // l2 被提升为 double，结果也是 double

在这个例子中，int类型的i1在与float类型的f4运算时被提升为float，结果也是float类型。同样地，long类型的l2在与double类型的d4运算时被提升为double，结果也是double类型。

---

4. 常量表达式中的类型

对于整数常量表达式（所有参与运算的操作数都是常量）：

• 如果结果在int范围内，那么结果类型是int。
• 如果结果超出int范围，那么结果类型是long。

示例：

byte b3 = 100;
byte b4 = 27;
byte result9 = (byte) (b3 + b4); // 结果类型是 int，需要显式转换为 byte

在上述例子中，尽管b3和b4都是byte类型，但表达式b3 + b4的结果是int类型，因此需要显式地进行类型转换才能赋值给byte类型的result9。

---

5、扩展赋值运算符:

+=   -=  *=  /=  %=  隐含了一个强制类型转换

public class Demo {
    public static void main(String[] args) {

        int x = 10;
        x += 20;// 等同于 x = (int)(x+20)
        System.out.println(x);

        byte a = 10;
        //a = a+20; 报错
        //a = (byte)(a+20);
        a += 20;// 等同于 a = (byte)(a+20);
        System.out.println(a);
    }
}

2、向上转型与向下转型

向上转型和向下转型是涉及对象引用类型转换的重要概念。它们在处理多态性、继承和接口时尤为重要。理解这两种转换的机制和应用场景有助于编写更灵活和健壮的代码。

向上转型

向上转型是指将子类对象转换为父类类型。这种转换是自动的，并且总是安全的，因为子类对象总是兼容于其父类类型。

特点：

1. 自动转换：向上转型是自动发生的，Java编译器会自动进行，不需要显式地进行类型转换。
2. 多态性：父类引用指向子类对象，这是实现多态的基础。
3. 局限性：在向上转型后，父类引用只能访问父类中定义的方法和属性，不能直接访问子类中特有的方法和属性。

示例代码：

class Animal {
    void eat() {
        System.out.println("吃食物");
    }
}

class Dog extends Animal {
    @Override
    void eat() {
        System.out.println("吃骨头");
    }
    
    void watch() {
        System.out.println("看家");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal = new Dog(); // 向上转型
        animal.eat(); // 输出: 吃骨头
        // animal.watch(); // 编译错误：无法调用子类特有的方法
    }
}

在上面的例子中，Dog类继承自Animal类。我们将Dog对象赋值给Animal类型的引用animal，这就是向上转型。animal只能调用Animal类中的方法，但由于eat()方法在Dog类中被重写，最终会调用Dog类的eat()方法，这就是多态性。

向下转型

向下转型是将父类类型的引用转换为子类类型的过程。这种转换并不是自动的，因为父类对象不一定是子类类型，所以这种转换有可能导致类型转换异常（ClassCastException）。向下转型通常用于访问子类特有的方法和属性。

特点：

1. 显式转换：向下转型需要显式进行类型转换（强制转换）。
2. 潜在的类型转换异常：如果父类引用的对象不是实际的子类类型，向下转型会导致ClassCastException。
3. 访问子类特性：向下转型后，可以访问子类特有的方法和属性。

示例代码：

class Animal {
    public void eat() {
        System.out.println("吃食物");
    }
}

class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("吃骨头");
    }

    public void watch() {
        System.out.println("看家");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal = new Dog();  // 向上转型

        if (animal instanceof Dog) {
            Dog dog = (Dog) animal;  // 向下转型
            dog.watch();  // 输出: 看家
        }
    }
}

在这个例子中，animal最初是一个Dog对象，但它被向上转型为Animal类型。为了调用Dog类中特有的方法watch()，我们需要将animal向下转型为Dog类型。向下转型前，我们使用instanceof进行类型检查，确保animal实际是Dog类型的实例。