# Java `instanceof`

> 原文： [https://www.programiz.com/java-programming/instanceof](https://www.programiz.com/java-programming/instanceof)

#### 在本教程中，您将在示例的帮助下详细了解 Java `instanceof`运算符。

在 Java 中，`instanceof`关键字是二进制运算符。 它用于检查对象是否是特定类的实例。

运算符还检查对象是否是实现接口的类的实例（将在本教程的后面进行讨论）。

`instanceof`的语法为：

```java
result = objectName instanceof className;
```

`instanceof`运算符的左操作数是对象名称，右操作数是类名称。 如果对象是类的实例，则结果为`true`，否则为`false`。

* * *

### 示例 1：`instanceof`

```java
class Main {
    public static void main (String[] args) {
        String name = "Programiz";
        Integer age = 22;

        System.out.println("Is name an instance of String: "+ (name instanceof String));
        System.out.println("Is age an instance of Integer: "+ (age instanceof Integer));
    }
}
```

**输出**：

```java
Is name an instance of String: true
Is age an instance of Integer: true
```

在上面的示例中，我们创建了`String`类型的对象`name`和`Integer`类型的另一个对象`age`。 然后，我们使用`instanceof`运算符检查`name`是否为`String`类型，以及`age`是否为`Integer`类型。

* * *

## 在继承中使用`instanceof`

在继承的情况下，`instanceof`运算符用于检查子类的对象是否也是超类的实例。

### 示例 2：继承中的`instanceof`

```java
class Animal {
}

// Dog class is a subclass of Animal
class Dog extends Animal {
}

class Main {
    public static void main(String[] args){
        Dog d1 = new Dog();

        // checks if d1 is an object of Dog
        System.out.println("Is d1 an instance of Dog: "+ (d1 instanceof Dog));

        // checks if d1 is an object of Animal
        System.out.println("Is d1 an instance of Animal: "+ (d1 instanceof Animal));
    }
}
```

**输出**：

```java
Is d1 is an instance of Dog: true
Is d1 an instance of Animal: true
```

在上面的示例中，`d1`是`Dog`和`Animal`类的实例。 因此，`d1 instanceof Dog`和`d1 instanceof Animal`都导致`true`。

* * *

## `Object`类

在 Java 中，所有类均继承自`Object`类。 在`Object`类的继承期间，不使用`extends`关键字。 这种继承隐式发生在 Java 中。

### 示例 3：`Object`类

```java
class Animal {
}

class Dog {
}

class Cat {
}
class Main {
    public static void main(String[] args) {
        Dog d1 = new Dog();
        Animal a1 = new Animal();
        Cat c1 = new Cat();

        System.out.println("Is d1 an instance of the Object class: "+ (d1 instanceof Object));
        System.out.println("Is a1 an instance of the Object class: "+ (a1 instanceof Object));

        System.out.println("Is c1 an instance of the Object class: "+ (c1 instanceof Object));
    }
}
```

**输出**：

```java
Is d1 an instance of the Object class: true
Is a1 an instance of the Object class: true
Is c1 an instance of the Object class: true
```

在上述示例中，我们创建了`Animal a1`，`Dog`类的`d1`和`Cat c1`。 我们已经使用`instanceof`运算符来检查这些对象`a1`，`d1`和`c1`是否也是`Object`类的对象 。 全部输出结果为`true`。

这是因为`Object`类是`java.lang`包中定义的根类。 所有其他类都是`Object`类的子类，在 Java 中形成层次结构。

* * *

## 对象向上转换和向下转换

在 Java 中，子类的对象可以视为超类的对象。 这称为向上转换。

Java 编译器自动执行向上转换。

### 示例 4：对象向上转换

```java
class Animal {
    public void displayInfo() {
        System.out.println("I am an animal.");
    }
}

class Dog extends Animal {
}

class Main {
    public static void main(String[] args) {
        Dog d1 = new Dog();
        Animal a1 = d1;
        a1.displayInfo();
    }
}
```

**输出**：

```java
I am an animal.
```

在上面的示例中，我们创建了`Dog`类的对象`d1`。 我们使用`d1`对象创建`Animal`类的对象`a1`。 在 Java 中，这称为向上转换。

该代码执行没有任何问题。 这是因为上载是由 Java 编译器自动完成的。

**向下转换是向上转换的相反过程。**

在向下转换的情况下，超类的对象被视为子类的对象。 我们必须明确指示编译器使用 Java 下调。

* * *

### 示例 5：对象向下转换问题

```java
class Animal {
}

class Dog extends Animal {
   public void displayInfo() {
       System.out.println("I am a dog.");
   }
}

class Main {
   public static void main(String[] args) {
       Animal a1 = new Animal();
       Dog d1 = (Dog)a1; // Downcasting

       d1.displayInfo();
   }
}
```

运行程序时，将获得名为`ClassCastException`的异常。 让我们看看这里发生了什么。

在这里，我们创建了超类`Animal`的对象`a1`。 然后，我们尝试将`a1`对象转换为子类`Dog`的对象`d1`。

这引起了问题。 这是因为超类`Animal`的`a1`对象也可能引用其他子类。 如果我们创建了另一个子类`Cat`和`Dog`，`Animal`可能是`Cat`，也可能是`Dog`引起歧义。

要解决此问题，我们可以使用`instanceof`运算符。 这是如何做：

* * *

### 示例 6：使用`instanceof`解决向下转换

```java
class Animal {
}

class Dog extends Animal {
  public void displayInfo() {
     System.out.println("I am a dog");
  }
}

class Main {
  public static void main(String[] args) {
    Dog d1 = new Dog();
    Animal a1 = d1;    // Upcasting

    if (a1 instanceof Dog){
       Dog d2 = (Dog)a1;    // Downcasting
       d2.displayInfo();
    }
  }
}
```

**输出**：

```java
I am a dog
```

在上面的示例中，我们使用`instanceof`运算符检查`a1`对象是否是`Dog`类的实例。 仅当表达式`a1 instanceof Dog`为`true`时才进行向下转换。

* * *

## 接口中的`instanceof`

`instanceof`运算符还用于检查类的对象是否也是实现该类的接口的实例。

### 示例 7：接口中的`instanceof`

```java
interface Animal {
}

class Dog implements Animal {
}

class Main {
   public static void main(String[] args) {
      Dog d1 = new Dog();
      System.out.println("Is d1 an instance of Animal: "+(d1 instanceof Animal));
   }
}
```

**输出**：

```java
Is d1 an instance of Animal: true
```

在上面的示例中，我们创建了一个`Dog`类，该类实现了`Animal`接口。

然后，创建`Dog`类的`d1`对象。 我们已经使用`instanceof`运算符检查`d1`对象是否也是`Animal`接口的实例。