Java中的类型转换-高级进阶

偏执的太偏执、 2022-01-20 04:45 216阅读 0赞

# 概述 #

我们知道Java类型系统由两种类型组成：基础类型和封装类型。

# 向上转型 #

从子类到超类的转换称为向上转型。通常，向上是由编译器隐式执行的。

向上转型与继承密切相关 - 这是Java中的另一个核心概念。使用引用变量来引用更具体的类型是很常见的。每次我们这样做时，都会发生隐式的向上转型。

我们定义一个Animal类：

public class Animal {
     
        public void eat() {
            // ... 
        }
    }
    复制代码

现在我们来扩展Animal：

public class Cat extends Animal {
     
        public void eat() {
             // ... 
        }
     
        public void meow() {
             // ... 
        }
    }
    复制代码

现在，我们可以创建一个对象Cat类，并把它分配给类型的引用变量cat：

`Cat cat = new Cat();`

我们还可以将它分配给Animal类型的引用变量：

`Animal animal = cat;`

在上面的分配中，发生了隐式的向上转换。我们可以明确地做到：

`animal = (Animal) cat;`

但是没有必要显式地继承继承树。编译器知道cat是Animal并且不显示任何错误。

注意，该引用可以引用声明类型的任何子类型。

使用向上转型，我们限制了Cat实例可用的方法数量，但没有更改实例本身。现在我们不能做任何特定于Cat的事情-我们不能在animal变量上调用meow()。

虽然Cat对象仍然是Cat对象，但调用meow()会导致编译器错误：

`// animal.meow(); The method meow() is undefined for the type Animal`

要调用meow()，我们需要向下转型animal，我们稍后会这样做。

但现在我们将描述是什么让我们向上转型，我们可以利用多态性。

## 多态性 ##

让我们定义Animal的另一个子类，一个Dog类：

public class Dog extends Animal {
     
        public void eat() {
             // ... 
        }
    }
    复制代码

现在我们可以定义feed（）方法来处理像动物一样的所有猫狗：

public class AnimalFeeder {
     
        public void feed(List<Animal> animals) {
            animals.forEach(animal -> {
                animal.eat();
            });
        }
    }
    复制代码

我们不希望AnimalFeeder关注列表中的哪种动物 - 猫或狗。在feed()方法中，它们都是动物。

当我们将特定类型的对象添加到动物列表时，会发生隐式向上转型：

List<Animal> animals = new ArrayList<>();
    animals.add(new Cat());
    animals.add(new Dog());
    new AnimalFeeder().feed(animals);
    复制代码

我们添加了猫和狗，它们被隐含地转向了Animal类型。每只猫都是动物，每只狗都是动物。他们是多态的。

顺便说一句，所有Java对象都是多态的，因为每个对象至少是一个Object。我们可以将一个Animal实例分配给Object类型的引用变量，编译器不会报错：

`Object object = new Animal();`

这就是为什么我们创建的所有Java对象都已经具有Object特定的方法，例如toString()。

向上转型到接口也很常见。

我们可以创建Mew接口并让Cat实现它：

public interface Mew {
        public void meow();
    }
     
    public class Cat extends Animal implements Mew {
         
        public void eat() {
             // ... 
        }
     
        public void meow() {
             // ... 
        }
    }
    复制代码

现在任何Cat对象也可以向上转换为Mew：

`Mew mew = new Cat();`

Cat是Mew，向上转型是合法的并且是隐含的。

因此，Cat是Mew，Animal，Object和Cat。在我们的示例中，它可以分配给所有四种类型的引用变量。

## 重写 ##

在上面的示例中，覆盖了eat()方法。这意味着尽管在Animal类型的变量上调用了eat()，但是工作是通过在真实对象上调用的方法完成的 - Cat和Dog：

public void feed(List<Animal> animals) {
        animals.forEach(animal -> {
            animal.eat();
        });
    }
    复制代码

如果我们在我们的类中添加一些日志记录，我们会看到Cat和Dog的方法被调用：

2019-05-29 17:48:49,354 [main] INFO com.william.casting.Cat - cat is eating
    2019-05-29 17:48:49,363 [main] INFO com.william.casting.Dog - dog is eating
    复制代码

**总结一下：**

*  如果对象与变量的类型相同或者它是子类型，则引用变量可以引用对象
 *  向上发生隐含的上行
 *  所有Java对象都是多态的，并且由于向上转型可以被视为超类型的对象

# 向下转型 #

如果我们想使用Animal类型的变量来调用仅适用于Cat类的方法，该怎么办？这是一个向下转型。它是从超类到子类的转换。

我们来举个例子：

Animal animal = new Cat();
    复制代码

我们知道动物变量是指Cat的实例。我们想在动物身上调用Cat的meow()方法。但编译器提示类型为Animal的meow()方法不存在。

应该将Animal转向Cat：

`((Cat) animal).meow();`

内括号和它们包含的类型有时称为强制转换运算符。请注意，编译代码也需要外部括号。

让我们用meow()方法重写之前的AnimalFeeder示例：

public class AnimalFeeder {
        public void feed(List<Animal> animals) {
            animals.forEach(animal -> {
                animal.eat();
                if (animal instanceof Cat) {
                    ((Cat) animal).meow();
                }
            });
        }
    }
    复制代码

现在我们可以访问Cat类可用的所有方法。查看日志以确保实际调用了meow()：

2019-05-29 18:28:19,445 [main] INFO com.william.casting.Cat - cat is eating
    2019-05-29 18:28:19,454 [main] INFO com.william.casting.Cat - meow
    2019-05-29 18:28:19,455 [main] INFO com.william.casting.Dog - dog is eating
    复制代码

请注意，在上面的示例中，我们尝试仅向下转换那些实际上是Cat实例的对象。为此，我们使用运算符instanceof。

## instanceof操作 ##

我们经常在向下转换之前使用instanceof运算符来检查对象是否属于特定类型：

if (animal instanceof Cat) {
        ((Cat) animal).meow();
    }
    复制代码

## ClassCastException异常 ##

如果我们没有使用instanceof运算符检查类型，编译器就不会报错。但在运行时，会有一个异常。

为了演示这个，让我们从上面的代码中删除instanceof运算符：

public void uncheckedFeed(List<Animal> animals) {
        animals.forEach(animal -> {
            animal.eat();
            ((Cat) animal).meow();
        });
    }
    复制代码

此代码编译没有问题。但如果我们尝试运行它，我们会看到一个异常：

java.lang.ClassCastException：com.william.casting.Dog无法强制转换为com.william.casting.Cat
    复制代码

这意味着我们正在尝试将作为Dog实例的对象转换为Cat实例。

如果我们向下转型的类型与真实对象的类型不匹配，则ClassCastException总是在运行时抛出。

注意，如果我们尝试向下转型为不相关的类型，编译器将不允许这样

Animal animal;
    String s = (String) animal;
    复制代码

编译器说“无法从Animal转换为String”。

对于要编译的代码，两种类型都应该在同一继承树中。

**我们总结一下：**

*  为了获得特定于子类的成员的访问权，必须进行向下转换
 *  使用强制转换运算符完成向下转换
 *  要安全地向下转换对象，我们需要instanceof运算符
 *  如果真实对象与我们向下转换的类型不匹配，则将在运行时抛出ClassCastException

## Cast()方法 ##

还有另一种使用Class方法强制转换对象的方法：

public void test() {
        Animal animal = new Cat();
        if (Cat.class.isInstance(animal)) {
            Cat cat = Cat.class.cast(animal);
            cat.meow();
        }
    }
    复制代码

在上面的示例中，使用了cast()和isInstance()方法，而不是相应的cast和instanceof运算符。

通常使用具有泛型类型的cast()和isInstance()方法。

让我们用feed()方法创建AnimalFeederGeneric 类，它只“喂”一种类型的动物 - Cat或Dog，取决于类型参数的值：

public class AnimalFeederGeneric<T> {
        private Class<T> type;
     
        public AnimalFeederGeneric(Class<T> type) {
            this.type = type;
        }
     
        public List<T> feed(List<Animal> animals) {
            List<T> list = new ArrayList<T>();
            animals.forEach(animal -> {
                if (type.isInstance(animal)) {
                    T objAsType = type.cast(animal);
                    list.add(objAsType);
                }
            });
            return list;
        }
     
    }
    复制代码

的feed()方法检查每个Animal，并返回仅那些的实例Ť。

注意，Class实例也应该传递给泛型类，因为我们无法从类型参数T中获取它。在我们的示例中，我们在构造函数中传递它。

让我们使T等于Cat并确保该方法仅返回cat：

@Test
    public void whenParameterCat_thenOnlyCatsFed() {
        List<Animal> animals = new ArrayList<>();
        animals.add(new Cat());
        animals.add(new Dog());
        AnimalFeederGeneric<Cat> catFeeder
          = new AnimalFeederGeneric<Cat>(Cat.class);
        List<Cat> fedAnimals = catFeeder.feed(animals);
     
        assertTrue(fedAnimals.size() == 1);
        assertTrue(fedAnimals.get(0) instanceof Cat);
    }
    复制代码

# 动态转换 #

在Java 5之前，以下代码将是常态：

List dates = new ArrayList();
    dates.add(new Date());
    Object object = dates.get(0);
    Date date = (Date) object;
    复制代码

需要转换。虽然运行时类型是Date，但编译器无法知道它。

使用泛型，可以重写上面的代码：

List<Date> dates = new ArrayList<>();
    dates.add(new Date());
    Date date = dates.get(0);
    复制代码

没有转换：由于泛型，编译器有足够的信息。

**强转换**

一个这样的用例是Servlet API。在servlet上下文/请求/会话中存储对象的映射不使用泛型。他们也会使用Object

// In a servlet
    ServletContext context = getServletContext();
    context.put("date", new Date());
    
    // Somewhere else
    ServletContext context = getServletContext();
    Object object = context.get("date");
    Date date = (Date) object;
    复制代码

\*\* 静态转换\*\*

使用Java进行强制转换的最常用方法如下：

Object obj; // may be an integer
    if (obj instanceof Integer) {
    	Integer objAsInt = (Integer) obj;
    	// do something with 'objAsInt'
    }
    复制代码

这使用了 instanceof和cast运算符。实例转换的类型（在本例中为 Integer）必须在编译时静态知道，所以让我们调用这个静态转换。

如果 obj不是 Integer，则上述测试将失败。如果我们试图抛出它，我们会得到一个 ClassCastException。如果 obj为 null，则它会使instanceof测试失败 但可以被强制转换，因为 null可以是任何类型的引用。

**动态转换**

最初可用的唯一转换形式是静态转换。这意味着需要在编译时知道转换类型。但是，让我们设想一个接受a的方法Stream，过滤特定类型的所有元素，并以正确的类型返回这些元素。这是用法的一个例子：

我遇到的一种技术不常使用Class上与运算符对应的方法 ：

Object obj; // may be an integer
    if (Integer.class.isInstance(obj)) {
    	Integer objAsInt = Integer.class.cast(obj);
    	// do something with 'objAsInt'
    }
    复制代码

请注意，虽然在此示例中，要编译的类在编译时也是已知的，但不一定如此：

Object obj; // may be an integer
    Class<T> type = // may be Integer.class
    if (type.isInstance(obj)) {
    	T objAsType = type.cast(obj);
    	// do something with 'objAsType'
    }
    复制代码

因为类型在编译类型是未知的，我们将称之为动态转换。

对于错误类型和空引用的实例，测试和强制转换的结果与静态强制转换的结果完全相同。

**现在**

转换Optional或Stream元素的值是一个两步过程：首先我们必须过滤掉错误类型的实例，然后我们可以转换为所需的类型。

使用Class上的方法 ，我们使用方法引用来完成此操作。使用Optional的示例 ：

Optional<?> obj; // may contain an Integer
    Optional<Integer> objAsInt = obj
    		.filter(Integer.class::isInstance)
    		.map(Integer.class::cast);
    复制代码

通过上面的写法，我们可以实现动态转换。

再举一个案例

List<?> items = ...
    List<Date> dates = filter(Date.class, items);
    复制代码

改造

static <T> List<T> filter(Class<T> clazz, List<?> items) {
        return items.stream()
            .filter(clazz::isInstance)
            .map(clazz::cast)
            .collect(Collectors.toList());
    }
    复制代码

以上为动态转换的demo案例，用这个写法可以实现动态转换。

## 总结 ##

本篇章介绍了Java类型转换的向上转换、向下转换、静态转换、动态转换。希望这些知识点可以对你有所帮助。