概述
我们知道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类型转换的向上转换、向下转换、静态转换、动态转换。希望这些知识点可以对你有所帮助。