instanceof在多态中用于判断对象实际类型，以便安全地进行向下转型并调用子类特有方法。
instanceof运算符在 Java 中用于检查对象是否是特定类的一个实例，或者是否是该类的子类的实例。它返回一个布尔值：
true或
false。
// 解决方案
public class Animal { }
public class Dog extends Animal { }
public class Main {
public static void main(String[] args) {
Animal animal = new Animal();
Dog dog = new Dog();
System.out.println(animal instanceof Animal); // true
System.out.println(dog instanceof Dog); // true
System.out.println(dog instanceof Animal); // true，因为 Dog 是 Animal 的子类
System.out.println(animal instanceof Dog); // false，Animal 不是 Dog 的子类
// 避免空指针异常
Animal nullAnimal = null;
System.out.println(nullAnimal instanceof Animal); // false，避免空指针异常
// 使用 instanceof 进行类型转换前的检查
if (animal instanceof Dog) {
Dog myDog = (Dog) animal; // 类型转换
// ...
} else {
System.out.println("animal 不是 Dog 类型的实例");
}
// 接口的判断
interface Swimmable { }
class Fish implements Swimmable { }
Fish fish = new Fish();
System.out.println(fish instanceof Swimmable); // true
}
}instanceof
在多态中的作用是什么？
多态允许将子类的对象视为父类的对象。
instanceof运算符可以帮助我们确定运行时对象的实际类型，这在处理集合或数组等包含不同类型对象的场景时非常有用。例如，你可能有一个
List，其中包含
Dog、
Cat和其他
Animal的子类实例。使用
instanceof，你可以区分这些实例并执行特定于类型的操作。
import java.util.ArrayList;
import java.util.List;
public class PolymorphismExample {
static class Animal {
public void makeSound() {
System.out.println("Generic animal sound");
}
}
static class Dog extends Animal {
@Override
public void makeSound() {
System.out.println("Woof!");
}
public void fetch() {
System.out.println("Dog is fetching the ball");
}
}
static class Cat extends Animal {
@Override
public void makeSound() {
System.out.println("Meow!");
}
public void scratch() {
System.out.println("Cat is scratching");
}
}
public static void main(String[] args) {
List animals = new ArrayList<>();
animals.add(new Dog());
animals.add(new Cat());
animals.add(new Animal());
for (Animal animal : animals) {
animal.makeSound(); // 多态调用，根据实际类型执行相应的方法
if (animal instanceof Dog) {
Dog dog = (Dog) animal;
dog.fetch(); // Dog 特有的方法
} else if (animal instanceof Cat) {
Cat cat = (Cat) animal;
cat.scratch(); // Cat 特有的方法
}
}
}
} 如何避免过度使用 instanceof
？
过度使用
instanceof通常表明设计上可能存在问题。例如，大量的
if-else或
switch语句基于
instanceof的结果来执行不同的代码，这违反了面向对象编程的开闭原则。一种常见的替代方案是使用多态。通过在父类中定义抽象方法，并在子类中实现这些方法，可以避免在运行时检查对象类型。
还有一种策略是使用访问者模式，它允许你在不修改对象结构的情况下定义新的操作。访问者模式特别适用于当需要对不同类型的对象执行许多不同的操作，并且这些操作之间的关系比较复杂时。
立即学习“Java免费学习笔记（深入）”；
// 使用多态避免 instanceof
abstract class Shape {
abstract void draw();
}
class Circle extends Shape {
@Override
void draw() {
System.out.println("Drawing a circle");
}
}
class Square extends Shape {
@Override
void draw() {
System.out.println("Drawing a square");
}
}
public class ShapeExample {
public static void main(String[] args) {
List shapes = new ArrayList<>();
shapes.add(new Circle());
shapes.add(new Square());
for (Shape shape : shapes) {
shape.draw(); // 无需 instanceof，直接调用 draw 方法
}
}
}
instanceof
和 getClass()
方法的区别？
instanceof检查对象是否是某个类或其子类的实例，而
getClass()返回对象的实际类。
instanceof考虑了继承关系，而
getClass()只比较对象的精确类型。
public class ClassVsInstanceof {
static class Animal {}
static class Dog extends Animal {}
public static void main(String[] args) {
Animal animal = new Animal();
Dog dog = new Dog();
Animal animalDog = new Dog(); // 多态
System.out.println(animal instanceof Animal); // true
System.out.println(dog instanceof Animal); // true
System.out.println(animalDog instanceof Animal); // true
System.out.println(animal instanceof Dog); // false
System.out.println(animal.getClass() == Animal.class); // true
System.out.println(dog.getClass() == Dog.class); // true
System.out.println(animalDog.getClass() == Dog.class); // true，注意这里是 Dog
System.out.println(animalDog.getClass() == Animal.class); // false
}
}getClass()方法通常用于需要精确类型匹配的场景，而
instanceof更适合于需要检查对象是否属于某个类层次结构的情况。选择哪种方法取决于你的具体需求。
