Java中instanceof合理使用探讨：接口可行，实现类不可行？

不少Java开发者对instanceof运算符颇有微词，社区里常提到：如果你的代码需要频繁使用instanceof，往往意味着设计可能存在缺陷——在设计良好的应用里应该尽量少用它，当然这条通用规则也有例外。不过这类讨论通常没说清到底什么时候能用、什么时候不能用。

我结合实践经验，总结出这么一条准则：对接口使用instanceof是合理可行的，直接对实现类使用则不推荐。

可行场景示例：基于接口的类型判断 #

假设我们有一个动物目录系统，部分动物具备飞行能力，我们可以通过接口来区分这类特性：

Animal.java #

public interface Animal {
    String getName();
    String makeNoise();
}

CanFly.java #

public interface CanFly {
    float getMaxInAirDistanceKm();
}

Cat.java #

public class Cat implements Animal {
    @Override
    public String getName() {
        return "Cat";
    }
    @Override
    public String makeNoise() {
        return "meow";
    }
}

BaldEagle.java #

public class BaldEagle implements Animal, CanFly {
    @Override
    public String getName() {
        return "BaldEagle";
    }
    @Override
    public String makeNoise() {
        return "whistle";
    }
    @Override
    public float getMaxInAirDistanceKm() {
        return 50;
    }
}

Catalog.java #

import java.util.ArrayList;
import java.util.List;
public class Catalog {
    private List<Animal> animals = new ArrayList<>();
    public void putAnimal(Animal animal) {
        animals.add(animal);
    }
    public void showList() {
        animals.forEach(animal -> {
            StringBuilder sb = new StringBuilder();
            sb.append(animal.getName() + ": ");
            sb.append(animal.makeNoise() + " ");
            // 针对具备飞行能力的动物做特定处理
            if (animal instanceof CanFly) {
                sb.append(String.format(" (can stay in air for %s km)", ((CanFly) animal).getMaxInAirDistanceKm()));
            }
            System.out.println(sb.toString());
        });
    }
    public static void main(String[] args){
        Catalog catalog = new Catalog();
        Cat cat = new Cat();
        BaldEagle baldEagle = new BaldEagle();
        catalog.putAnimal(cat);
        catalog.putAnimal(baldEagle);
        catalog.showList();
    }
}

测试输出：

Cat: meow
BaldEagle: whistle (can stay in air for 50.0 km)

这里的instanceof CanFly是合理的，因为我们判断的是动物是否具备飞行能力这个抽象特性，而非某个具体的实现类。后续如果新增其他会飞的动物（比如Sparrow implements Animal, CanFly），代码不需要做任何修改就能支持。

不可行场景示例：基于实现类的类型判断 #

如果我们去掉CanFly接口，直接在代码里判断具体的实现类BaldEagle，代码会变成这样：

修改后的Catalog.java的showList方法 #

public void showList() {
    animals.forEach(animal -> {
        StringBuilder sb = new StringBuilder();
        sb.append(animal.getName() + ": ");
        sb.append(animal.makeNoise() + " ");
        if (animal instanceof BaldEagle) {
            sb.append(String.format(" (can stay in air for %s km)", ((BaldEagle) animal).getMaxInAirDistanceKm()));
        }
        System.out.println(sb.toString());
    });
}

这种写法就很不合理了——代码现在直接依赖具体的实现类BaldEagle，而不是抽象的能力。比如如果后续我们需要把BaldEagle替换成另一个实现类BaldEagleImpl（同样具备飞行能力），这段代码就会失效：它只会识别原来的BaldEagle类，而不会处理新的实现类，完全违反了面向对象的依赖倒置原则。

内容的提问来源于stack exchange，提问作者leeyuiwah