什么是“实例”？ Java 中使用的运算符？

Question

instanceof 运算符的用途是什么？我见过类似的东西

if (source instanceof Button) {
    //...
} else {
    //...
}

，但对我来说没有任何意义。我已经完成了研究，但只提供了示例，没有任何解释。

Answer 1

如果表达式的左侧是右侧类名的实例，则该运算符返回 true。

这样想吧。假设您所在街区的所有房屋都是按照相同的蓝图建造的。十栋房子（对象），一套蓝图（类定义）。

当您拥有一组对象但不确定它们是什么时，instanceof 是一个有用的工具。假设您在表单上有一组控件。您想要读取那里的任何复选框的选中状态，但您不能向普通的旧对象询问其选中状态。相反，您会查看每个对象是否是一个复选框，如果是，则将其转换为复选框并检查其属性。

if (obj instanceof Checkbox)
{
    Checkbox cb = (Checkbox)obj;
    boolean state = cb.getState();
}

Answer 2

如此网站所述：

instanceof 运算符可用于测试对象是否属于
具体类型...

if（对象引用实例类型）

一个简单的例子：

String s = "Hello World!"
返回 String 的实例；
//结果-->真的

但是，在空引用变量/表达式上应用 instanceof
返回 false。

字符串 s = null;
返回 String 的实例；
//结果-->错误的

由于子类是其超类的“类型”，因此您可以使用
instanceof 来验证这一点...

类父级{
    公共父级（）{}
}

类子类扩展父类{
    公共儿童（）{
        极好的（）;
    }
}

公共类主要{
    公共静态无效主（字符串[] args）{
        子孩子 = new Child();
        System.out.println(Parent 的子实例);
    }
}
//结果-->真的

我希望这有帮助！

Answer 3

该运算符允许您确定对象的类型。
它返回一个布尔值。

例如

package test;

import java.util.Date;
import java.util.Map;
import java.util.HashMap;

public class instanceoftest
{
    public static void main(String args[])
    {
        Map m=new HashMap();
        System.out.println("Returns a boolean value "+(m instanceof Map));
        System.out.println("Returns a boolean value "+(m instanceof HashMap));
        System.out.println("Returns a boolean value "+(m instanceof Object));
        System.out.println("Returns a boolean value "+(m instanceof Date));
    }
} 

输出是：

Returns a boolean value true
Returns a boolean value true
Returns a boolean value true
Returns a boolean value false

Answer 4

如果 source 是一个 object 变量，则 instanceof 是一种检查它是否是 Button 的方法。

Answer 5

正如其他答案中提到的，instanceof 的规范典型用法是检查标识符是否引用更具体的类型。示例：

Object someobject = ... some code which gets something that might be a button ...
if (someobject instanceof Button) {
    // then if someobject is in fact a button this block gets executed
} else {
    // otherwise execute this block
}

但请注意，左侧表达式的类型必须是右侧表达式的父类型（请参阅JLS 15.20.2 和 Java Puzzlers，#50，第 114 页）。例如，以下内容将无法编译：

public class Test {
    public static void main(String [] args) {
        System.out.println(new Test() instanceof String); // will fail to compile
    }
}

编译失败，并显示消息：

Test.java:6: error: inconvertible types
        System.out.println(t instanceof String);
                       ^
  required: String
  found:    Test
1 error

As Test is not aparent class of String。 OTOH，这可以完美编译并按预期打印 false ：

public class Test {
    public static void main(String [] args) {
        Object t = new Test();
        // compiles fine since Object is a parent class to String
        System.out.println(t instanceof String); 
    }
}

Answer 6

public class Animal{ float age; }

public class Lion extends Animal { int claws;}

public class Jungle {
    public static void main(String args[]) {

        Animal animal = new Animal(); 
        Animal animal2 = new Lion(); 
        Lion lion = new Lion(); 
        Animal animal3 = new Animal(); 
        Lion lion2 = new Animal();   //won't compile (can't reference super class object with sub class reference variable) 

        if(animal instanceof Lion)  //false

        if(animal2 instanceof Lion)  //true

        if(lion insanceof Lion) //true

        if(animal3 instanceof Animal) //true 

    }
}

Answer 7

大多数人都正确解释了这个问题的“什么”，但没有人正确解释“如何”。

所以这里有一个简单的说明：

String s = new String("Hello");
if (s instanceof String) System.out.println("s is instance of String"); // True
if (s instanceof Object) System.out.println("s is instance of Object"); // True
//if (s instanceof StringBuffer) System.out.println("s is instance of StringBuffer"); // Compile error
Object o = (Object)s;
if (o instanceof StringBuffer) System.out.println("o is instance of StringBuffer"); //No error, returns False
else System.out.println("Not an instance of StringBuffer"); // 
if (o instanceof String) System.out.println("o is instance of String"); //True

输出：

s is instance of String
s is instance of Object
Not an instance of StringBuffer
o is instance of String

将 s 与 StringBuffer 进行比较时编译器错误的原因在 文档：

您可以使用它来测试对象是否是类的实例、子类的实例或实现特定接口的类的实例。

这意味着 LHS 必须是 RHS 的实例，或者是实现 RHS 或扩展 RHS 的类的实例。

那么如何使用use instanceof呢？
由于每个类都扩展了对象，因此将 LHS 类型转换为对象将始终对您有利：

String s = new String("Hello");
if ((Object)s instanceof StringBuffer) System.out.println("Instance of StringBuffer"); //No compiler error now :)
else System.out.println("Not an instance of StringBuffer");

输出：

Not an instance of StringBuffer

Answer 8

最好的解释是 jls。
始终尝试检查消息来源的说法。在那里您将得到最好的答案以及更多。
在这里复制一些部分：

instanceof 的 RelationalExpression 操作数的类型
运算符必须是引用类型或 null 类型；否则，一个
发生编译时错误。

如果后面提到的ReferenceType是编译时错误
instanceof 运算符不表示可具体化的引用类型
（§4.7）。

如果将 RelationalExpression 强制转换（第 15.16 节）到 ReferenceType
将被视为编译时错误而被拒绝，然后 instanceof
关系表达式同样会产生编译时错误。在这样的
在这种情况下，instanceof 表达式的结果永远不可能是
正确。

Answer 9

instanceof 运算符将对象与指定类型进行比较。您可以使用它来测试对象是否是类的实例、子类的实例或实现特定接口的类的实例。

http://download.oracle.com/javase/tutorial/java/nutsandbolts /op2.html

Answer 10

当您想了解特定对象的实例时，Instance of 关键字很有帮助。

假设您抛出异常，当您捕获时，执行 sum 自定义操作，然后再次按照您的逻辑继续（抛出或日志等）

示例：
1) 用户创建了自定义异常“InvalidExtensionsException”并按照逻辑抛出它

2) 现在在 catch 块中
捕获（异常e）{
如果异常类型为“InvalidExtensionsException”，则执行求和逻辑

InvalidExtensionsException InvalidException =(InvalidExtensionsException)e;

3) 如果您不检查实例且异常类型为空指针异常，您的代码将中断。

所以你的逻辑应该在实例内部
if (e实例InvalidExtensionsException){
InvalidExtensionsException InvalidException =(InvalidExtensionsException)e;
上面

的例子是错误的编码实践，但是这个例子可以帮助您理解它的实例的使用。

Answer 11

java instanceof 运算符用于测试对象是否是指定类型（类或子类或接口）的实例。

java中的instanceof也称为类型比较运算符，因为它将实例与类型进行比较。它返回 true 或 false。如果我们将 instanceof 运算符应用于任何具有 null 值的变量，它将返回 false。

从包含 JEP 305 的 JDK 14+ 开始，我们还可以对 进行“模式匹配” instanceof

模式基本上测试一个值是否具有某种类型，并且当它具有匹配的类型时可以从该值中提取信息。
模式匹配允许更清晰、更有效地表达系统中的通用逻辑，即有条件地从对象中删除组件。

Java 14之前

if (obj instanceof String) {
    String str = (String) obj; // need to declare and cast again the object
    .. str.contains(..) ..
}else{
     str = ....
}

Java 14增强功能

if (!(obj instanceof String str)) {
    .. str.contains(..) .. // no need to declare str object again with casting
} else {
    .. str....
}

我们还可以将类型检查和其他条件结合在一起

if (obj instanceof String str && str.length() > 4) {.. str.contains(..) ..}

在 instanceof 中使用模式匹配应该可以减少总数Java 程序中的显式强制转换。

PS：instanceOf只有在对象不为null时才会匹配，然后才可以赋值给str。

Answer 12

可以用作相等检查的简写。

所以这段代码

if(ob != null && this.getClass() == ob.getClass) {
}

可以写成

if(ob instanceOf ClassA) {
}
 

Answer 13

当对象（listObj）中存在的元素类型在运行时未知时，也可以使用 instanceof 运算符。在这些情况下，instanceof 运算符可用于确定元素类型，并将有助于根据要求进一步进行操作。

例如：

   String str = "";
   int a = 0;
   Integer b = null;

    List listObj = new ArrayList<>();
    listObj.add("String");
    listObj.add(100);
    listObj.add(10.5);
    listObj.add(1l);
    
    if (listObj.get(0) instanceof String) {
        System.out.println("String");
        str = (String)listObj.get(0);
    }
    
    if (listObj.get(1) instanceof Integer) {
        System.out.println("Integer");
         a = (int)listObj.get(1);
         b = (Integer)listObj.get(1);
    }
    
    if (listObj.get(2) instanceof Double) {
        System.out.println("Double");
    }
    
    if (listObj.get(3) instanceof Long) {
        System.out.println("Long");
    }

如果从对象检索的值分配给一个变量，JVM 会要求您在编译时将其转换为特定类型。

让我们考虑一下：

int x = (String)listObj.get(0); 

// 在上面的示例中，从 listObj 检索的元素是 String 并被转换为 int。这将解决编译时错误。但是在执行时JVM将抛出ClassCastException。

因此，我们可以使用instanceof运算符来检查并将值分配给正确的变量，以避免错误，而不是随机分配值给与类型不匹配的变量。

Answer 14

class Test48{
public static void main (String args[]){
Object Obj=new Hello();
//Hello obj=new Hello;
System.out.println(Obj instanceof String);
System.out.println(Obj instanceof Hello);
System.out.println(Obj instanceof Object);
Hello h=null;
System.out.println(h instanceof Hello);
System.out.println(h instanceof Object);
}
}  

Answer 15

非常简单的代码示例：

If (object1 instanceof Class1) {
   // do something
} else if (object1 instanceof Class2) {
   // do something different
}

这里要小心。在上面的示例中，如果 Class1 是 Object，则第一次比较将始终为 true。因此，就像例外一样，等级顺序很重要！

Answer 16

您可以使用 Map 对实例进行更高的抽象

private final Map<Class, Consumer<String>> actions = new HashMap<>();

然后让这样的映射向其添加一些操作：

actions.put(String.class, new Consumer<String>() {
        @Override
        public void accept(String s) {
           System.out.println("action for String");       
        }
    };

然后如果有一个未知类型的对象，您可以从该映射中获取特定的操作：

actions.get(someObject).accept(someObject)

Answer 17

instanceof 运算符用于检查对象是否是指定类型的实例。 （类或子类或接口）。

instanceof 也称为类型比较运算符，因为它将实例与类型进行比较。它返回 true 或 false。

class Simple1 {  
public static void main(String args[]) {  
Simple1 s=new Simple1();  
System.out.println(s instanceof Simple1); //true  
}  
}  

如果我们对任何具有 null 值的变量应用 instanceof 运算符，它将返回 false。

Answer 18

instanceof 关键字是一个二元运算符，用于测试对象（实例）是否是给定类型的子类型。

想象一下：

interface Domestic {}
class Animal {}
class Dog extends Animal implements Domestic {}
class Cat extends Animal implements Domestic {}

想象一个狗对象，用Objectdog = new Dog()创建，然后：

dog instanceof Domestic // true - Dog implements Domestic
dog instanceof Animal   // true - Dog extends Animal
dog instanceof Dog      // true - Dog is Dog
dog instanceof Object   // true - Object is the parent type of all objects

但是，用Objectanimal=new 创建Animal();，

animal instanceof Dog // false

因为 Animal 是 Dog 的超类型，并且可能不太“精致”。

而且，

dog instanceof Cat // does not even compile!

这是因为 Dog 既不是 Cat 的子类型，也不是 Cat 的超类型，并且它也没有实现它。

请注意，上面用于 dog 的变量是 Object 类型。这是为了表明 instanceof 是一个运行时操作，并将我们带到一个/用例：在运行时根据对象类型做出不同的反应 。

需要注意的是：对于所有类型 T，expressionThatIsNull instanceof T 都是 false。