Question

以下代码段抛出NullPointerException。它是Scala的预期和正常行为吗？

object ATest extends App {
    def getX[T <: X](constr: ⇒ T = null.asInstanceOf[T]): Unit = {
        constr
    }
    getX()
}
class X

从代码段生成（解密）Java代码：

public final class ATest {
public static void main(String[] arrstring) {
    ATest$.MODULE$.main(arrstring);
}
public static void delayedInit(Function0<BoxedUnit> function0) {
    ATest$.MODULE$.delayedInit(function0);
}
public static String[] args() {
    return ATest$.MODULE$.args();
}
public static void scala$App$_setter_$executionStart_$eq(long l) {
    ATest$.MODULE$.scala$App$_setter_$executionStart_$eq(l);
}
public static long executionStart() {
    return ATest$.MODULE$.executionStart();
}
public static void delayedEndpoint$test$ATest$1() {
    ATest$.MODULE$.delayedEndpoint$test$ATest$1();
}
public static <T extends X> T getX$default$1() {
    return ATest$.MODULE$.getX$default$1();
}
public static <T extends X> void getX(Function0<T> function0) {
    ATest$.MODULE$.getX(function0);
}
}


public final class ATest$ implements App {
public static final ATest$ MODULE$;
private final long executionStart;
private String[] scala$App$$_args;
private final ListBuffer<Function0<BoxedUnit>> scala$App$$initCode;

public static {
    new test.ATest$();
}
public long executionStart() {
    return this.executionStart;
}
public String[] scala$App$$_args() {
    return this.scala$App$$_args;
}
public void scala$App$$_args_$eq(String[] x$1) {
    this.scala$App$$_args = x$1;
}
public ListBuffer<Function0<BoxedUnit>> scala$App$$initCode() {
    return this.scala$App$$initCode;
}
public void scala$App$_setter_$executionStart_$eq(long x$1) {
    this.executionStart = x$1;
}
public void scala$App$_setter_$scala$App$$initCode_$eq(ListBuffer x$1) {
    this.scala$App$$initCode = x$1;
}
public String[] args() {
    return App.class.args((App)this);
}
public void delayedInit(Function0<BoxedUnit> body) {
    App.class.delayedInit((App)this, body);
}
public void main(String[] args) {
    App.class.main((App)this, (String[])args);
}
public <T extends X> void getX(Function0<T> constr) {
    constr.apply();
}
public <T extends X> T getX$default$1() {
    return null;
}
public final void delayedEndpoint$test$ATest$1() {
    this.getX((Function0<T>)new scala.Serializable(){
        public static final long serialVersionUID = 0;

        public final Nothing. apply() {
            return (Nothing.)ATest$.MODULE$.getX$default$1();
        }
    });
}
private ATest$() {
    MODULE$ = this;
    App.class.$init$((App)this);
    this.delayedInit((Function0<BoxedUnit>)new ATest.delayedInit$body(this));
}
}

public final class ATest$.anonfun extends AbstractFunction0<Nothing.>implements Serializable {
public final Nothing. apply() {
        return (Nothing.)ATest$.MODULE$.getX$default$1();
        }
}

最后行动部分：

public <T extends X> void getX(Function0<T> constr) {
    constr.apply();
}
public <T extends X> T getX$default$1() {
    return null;
}
public final void delayedEndpoint$test$ATest$1() {
    this.getX((Function0<T>)new scala.Serializable(){
        public final Nothing. apply() {
            return (Nothing.)ATest$.MODULE$.getX$default$1();
        }
    });
}

即：调用getX传递新的anon Function0，apply（）只调用getX $ default $ 1（）为null。所以我看不出任何可以抛出NPE的点。

编辑：找到未解决的问题：https://issues.scala-lang.org/browse/SI-8097

编辑：表达式null.asInstanceOf [T]为类型T生成默认值。如果Scala将结果类型T推断为Nothing，我们来到运行时表达式

null.asInstanceOf[Nothing]

显然抛出Exeption作为Nothing的默认值是Exception。

但是为什么这个片段仅在最后一行抛出NPE？

object ATest extends App {
    def getX[T](x: T = null.asInstanceOf[T]): T = x
    getX[Nothing]() // Ok
    val x = getX() // Ok 
    val y = null
    println("x= "+x) // prints 'x= null'
    println(s"y= $y") // prints 'y= null'
    println(s"x= $x") // throws NPE !?
    println("x==null ? "+(x==null)) // prints 'x= null'
}

为什么这个片段会抛出NPE（它只与以前的隐式参数不同）？

object ATest extends App {
    def getX[T](x: T = null.asInstanceOf[T])(implicit s: String = null): T = x
    getX() // throws NPE !?
}

所以情况仍然模糊不清。问题是开放的。

Answer 1

所以我必须稍微修改一下我的答案。

然而，从字节代码中可以清楚地看到NPE的触发因素，而不是反向编译的Java代码。字节代码比Java代码具有更多功能，重要的是，您可以使用两种方法，这些方法仅在返回类型方面有所不同，并且可以执行不同的操作。

首先让我们看看堆栈跟踪：

at ATest$$anonfun$1.apply(Test.scala:7)
at ATest$.getX(Test.scala:5)
at ATest$.delayedEndpoint$ATest$1(Test.scala:7)
at ATest$delayedInit$body.apply(Test.scala:3)
at scala.Function0$class.apply$mcV$sp(Function0.scala:40)
at scala.runtime.AbstractFunction0.apply$mcV$sp(AbstractFunction0.scala:12)
at scala.App$$anonfun$main$1.apply(App.scala:76)
at scala.App$$anonfun$main$1.apply(App.scala:76)
at scala.collection.immutable.List.foreach(List.scala:383)
at scala.collection.generic.TraversableForwarder$class.foreach(TraversableForwarder.scala:35)
at scala.App$class.main(App.scala:76)
at ATest$.main(Test.scala:3)
at ATest.main(Test.scala)

所以出现问题的方法是ATest $$ anonfun $ 1.apply

让我们看看：

public final scala.runtime.Nothing$ apply();
Code:
   0: getstatic     #19                 // Field ATest$.MODULE$:LATest$;
   3: invokevirtual #23                 // Method ATest$.getX$default$1:()LX;
   6: checkcast     #25                 // class scala/runtime/Nothing$
   9: areturn

public final java.lang.Object apply();
Code:
   0: aload_0
   1: invokevirtual #30                 // Method apply:()Lscala/runtime/Nothing$;
   4: athrow

我们注意到的第一件事是有两个叫做apply的方法，所以调用了一个方法（这是一个提示......）好吧，让我们看一下调用它的方法：

public <T extends X> void getX(scala.Function0<T>);
Code:
   0: aload_1
   1: invokeinterface #62,  1  // InterfaceMethod scala/Function0.apply:()Ljava/lang/Object;
   6: pop
   7: return

因此，我们调用返回Object的那个并且具有athrow指令。那么为什么会给我们一个NullPointer异常？

好吧，该方法执行以下操作：它将它放在堆栈上，然后调用另一个apply方法（返回Nothing $），此方法实际上返回null，因为它返回我们的默认参数。现在我们在堆栈上有一个null并执行athrow。如果它在堆栈上找到null，则会抛出NPE。

这就是这里发生的事情。

接下来的问题是，为什么会发生？

好吧，让我们看一下scracc在做出类型检查之后会做些什么：

object ATest extends AnyRef with App {
    def <init>(): ATest.type = {
      ATest.super.<init>();
      ()
    };
    def getX[T <: X](constr: => T = null.asInstanceOf[T]): Unit = {
      constr;
      ()
    };
    <synthetic> def getX$default$1[T <: X]: T = null.asInstanceOf[T];
    ATest.this.getX[Nothing](ATest.this.getX$default$1[Nothing])
  }

在没有asInstanceOf的情况下它会做什么：

object ATest extends AnyRef with App {
    def <init>(): ATest.type = {
      ATest.super.<init>();
      ()
    };
    def getX[T <: X](constr: => T = null): Unit = {
      constr;
      ()
    };
    <synthetic> def getX$default$1[T <: X]: Null = null;
    ATest.this.getX[Null](ATest.this.getX$default$1[Nothing])
  }

嗯，不知何故，默认参数为Null的信息在第一种情况下会丢失。

在第二种情况下，我们得到关键方法的字节代码：

public final java.lang.Object apply();
Code:
   0: aload_0
   1: invokevirtual #27                 // Method apply:()Lscala/runtime/Null$;
   4: pop
   5: aconst_null
   6: areturn

所以在这里，编译器知道，参数为null，并使用类Null $生成代码为null。

会发生什么？

嗯，肯定不是空指针异常。但是为什么编译器首先会产生这种情况呢？可能是因为asInstanceOf [T]变成asInstanceOf [Nothing]，如果在null上调用它应该抛出异常。

让我们快速尝试一下，如果我们在repl中这样做会发生什么：

"".asInstanceOf[Nothing]
java.lang.ClassCastException: java.lang.String cannot be cast to scala.runtime.Nothing$

到目前为止很好，而且：

null.asInstanceOf[Nothing]
java.lang.NullPointerException

好吧，也许我应该从这开始...看来，asInstanceOf的代码生成有一些bug并抛出了错误的异常。

为什么下限：＆gt; Null修复了这个问题，也很清楚：推断类型不再是Nothing而是Null，而instanceOf也没问题。

因此，更有趣的问题是为什么类型检查器在您现在已删除的复杂示例上失败。

复杂的例子

class X
object ATest extends App {
  def getX[T<:X](clas: Class[T], constr: ⇒ T = null): T ={
    val x = constr
    if (x == null) clas.newInstance() else x
  }
  val clas: Class[_ <: X] = classOf[X]
  getX(clas) // Ooops: type mismatch..
}

嗯，类型检查员说了什么：

def getX[T <: X](clas: Class[T], constr: => T = null): T = {
  val x: T = constr;
    if (x.==(null))
      clas.newInstance()
    else
      x
  };
  <synthetic> def getX$default$2[T <: X]: Null = null;
  private[this] val clas: Class[_ <: X] = classOf[X];
  <stable> <accessor> def clas: Class[_ <: X] = ATest.this.clas;
  ATest.this.getX[T](<clas: error>, ATest.this.getX$default$2)
}

不知怎的，他无法推断T的类型，但他应该推断出Null，因为只有引用类型的类。有趣的是，编译器不知道这一点。它似乎直接使用来自Java的Class中的定义，并且类型参数没有下限（因为Java没有类型Null），因此下限是Nothing。这也告诉我们，如何解决它：

val clas: Class[_ >: Null <: X] = classOf[X]
getX(clas)

这终于奏效了。所以你可以做到，你想做的事情首先。您只需要告诉编译器，您对不能为空的类型的类不感兴趣。

我认为我仍然更喜欢带有Option的版本：

def getX[T <: X](clas: Class[T], constr: ⇒ Option[T] = None): T = {
  val x = constr
   x match {
    case None => clas.newInstance()
    case Some(x) => x
  }
}
val clas: Class[_ <: X] = classOf[X]
getX(clas)

现在也很清楚，为什么这样做：None是Option [Nothing]，所以这段代码可以处理Class [Nothing]就好了。

带有默认null的Scala by-name参数会抛出NullPointerException

1 个答案:

接下来的问题是，为什么会发生？

会发生什么？

复杂的例子