什么是NullPoInterException，如何修复它？

Question

什么是null指针异常（ java.lang.nullpointerexception ），什么导致它们？

可以使用哪些方法/工具来确定原因，以便您阻止异常导致程序过早终止程序？

Answer 1

Java中有两种总体变量类型：

1. primitives ：包含数据的变量。如果要在原始变量中操纵数据，则可以直接操纵该变量。按照惯例原始类型以小写字母开头。例如，类型 int 或 char 的变量是原始。

2. 参考：包含对象的内存地址的变量，即参考的变量 object 。如果要操纵对象参考变量指的是您必须 dereference it。使用。进行删除，以访问方法或字段，或使用 [索引一个数组。按照惯例，参考类型通常用大写启动的类型表示。例如，类型对象的变量是引用。

考虑以下代码在其中声明 oprive type int 的变量，并且不初始化：

int x;
int y = x + x;

这两行会崩溃程序，因为没有为> x ，我们正在尝试使用 x 的值来指定 y 。所有原语都必须在操纵之前将其初始化为可用值。

现在这是事情变得有趣的地方。 参考可以将变量设置为 null ，其意思是“ 我正在引用 nothing ”。如果您明确设置 null 值，则可以在参考变量中获取 value，或者是非初始化的参考变量，并且编译器不会捕获它（Java将自动将变量设置为 code> null ）。

如果将参考变量设置为由您或通过Java自动显式null，并且您尝试使用 deReference ，则会获得 nullpoInterException 。

nullpoInterException （npe）通常会在声明变量但未创建对象时发生并在尝试使用变量的内容之前将其分配给变量。因此，您可以参考实际上不存在的事物。

采用以下代码：

Integer num;
num = new Integer(10);

第一行声明一个名为 num 的变量，但实际上尚未包含参考值。由于您还没有说要指向的内容，因此Java将其设置为 null 。

在第二行中， new 关键字用于实例化（或创建）类型 Integer 的对象，并且参考变量 num 已分配到该整数对象。

如果您尝试在创建对象之前取消 num ，则获得 nullpoInterException 。在大多数琐碎的情况下，编译器会遇到问题，并让您知道“ num可能没有初始化”，但是有时您可能会编写不会直接创建对象的代码。

例如，您可能具有以下方法：

public void doSomething(SomeObject obj) {
   // Do something to obj, assumes obj is not null
   obj.myMethod();
}

在这种情况下，您不是创建对象 obj ，而是假设它是在 dosomething（）方法之前创建的被称为。请注意，可以调用这样的方法：

doSomething(null);

在这种情况下， obj is null ，语句 obj.mymethod（）将投掷 NullPoInterException 。

如果该方法的目的是像上述方法一样对传递对象做某事，则可以扔 nullpoInterException ，因为它是程序员错误，并且程序员将需要该信息来进行调试目的。

除了 NullPoInterException 由于该方法的逻辑而引发的结果外，您还可以检查 null 值的方法参数，并通过在附近附近添加类似的内容来明确抛出NPES方法的开始：

// Throws an NPE with a custom error message if obj is null
Objects.requireNonNull(obj, "obj must not be null");

请注意，在错误消息中说出 对象不能为 null ，这很有帮助。验证这一点的优点是，1）您可以返回自己的清晰错误消息，而2）对于其余方法，您知道，除非 obj 重新分配，否则它不是null，并且可以安全地删除。

或者，在某些情况下，该方法的目的不仅是在对象中传递的对象上操作，因此可以接受零参数。在这种情况下，您需要检查 null参数并以不同的方式行事。您还应该在文档中解释这一点。例如， dosomething（）可以写为：

/**
  * @param obj An optional foo for ____. May be null, in which case
  *  the result will be ____.
  */
public void doSomething(SomeObject obj) {
    if(obj == null) {
       // Do something
    } else {
       // Do something else
    }
}

最后，如何查明例外＆amp;导致使用堆栈跟踪

可以使用哪些方法/工具来确定原因，以便您停止
导致程序过早终止的例外？

带有发现错误的声纳可以检测到NPE。
Sonar Cath cath null Catch null Catch null Pointer waull catch null Pointer waull jvm造成的null Pointer drominally jvM a>

现在，Java 14添加了一个新的语言功能，以显示NullPoInterException的根本原因。自2006年以来，此语言功能一直是SAP商业JVM的一部分。

在Java 14中，以下是示例NullPoInterException exceptions：

在线程“ main” java.lang.lang.nullpointerexception中：无法调用“ java.util.list.size（）”，因为“列表”是null

导致 nullpoInterException 发生的情况

。 nullpoInterException 发生的情况是，Java语言规范直接*提及的情况：

• 访问（IE fet或设置）实例 null引用的字段。 （静态字段不计数！）
• 调用null引用的实例方法。 （静态方法不计算！）
• 抛出null;
• 访问空数组的元素。
• 在null上同步 - 同步（somenullReference）{...}
• 任何整数/浮点操作员都可以抛出 nullpoInterException 如果其操作数之一是盒装的null null null null null引用
• 的转换转换如果盒装值为null，则抛出 nullpoInterException 。
• 在null引用上呼叫 super thring thring a nullpoInterException 。如果您感到困惑，这是在谈论合格的超级类构造函数：

class Outer {
    class Inner {}
}
class ChildOfInner extends Outer.Inner {
    ChildOfInner(Outer o) { 
        o.super(); // if o is null, NPE gets thrown
    }
}

• 使用 for（element：eyterable）循环通过null Collection/array循环。

  


• switch（foo）{...} （其表达式还是语句）可以抛出 nullpointerexpection foo> foo 是null。

• foo.new someinnerClass（）抛出 nullpointerexception foo null。

• 表单的方法参考 name1 :: name2 或 primary Expression :: name 当评估 name1 或 primary Expression 评估为null。

  此处的JLS的注释说， someInstance.somestaticMethod（）不会抛出NPE，因为 somestaticMethod 是静态的，但是 someinstance :::::::: SomestaticMethod 仍然扔NPE！

_{*请注意，JLS可能还说了很多关于NPES 间接。}

Answer 2

nullPoInterException 是当您尝试使用引用内存中没有位置（null）的参考时，就会出现异常，就像它在引用对象一样。在null引用上调用方法或试图访问空引用的字段将触发 nullpointerexception 。这些是最常见的，但是其他方法在 NullPoInterException Javadoc页面。

我可能想出的最快示例代码可以说明 nullpointerexception 是：

public class Example {

    public static void main(String[] args) {
        Object obj = null;
        obj.hashCode();
    }

}

在 main 内的第一行上，我明确设置 object 参考 obj 等于 null 。这意味着我有一个参考，但没有指向任何对象。之后，我尝试将引用视为通过调用方法指向对象的参考。这将导致 nullpoInterException ，因为在引用指向的位置中没有代码可以执行。

（这是一种技术性，但我认为它提到了：指向null的参考与指向无效内存位置的C指针不同。零指针实际上不是指向 whice ，这与指向恰好无效的位置有明显不同。）

Answer 3

什么是NullPoInterException？

一个好的起点是 javadocs 。他们涵盖了这一点：

在应用程序尝试使用null的情况下，在
需要对象。这些包括：

• 调用空对象的实例方法。
• 访问或修改空对象的字段。
• 将零的长度占用，好像是一个数组。
• 访问或修改null的插槽，就好像是数组一样。
• 将无效的扔掉，好像是可抛价的价值。

应用程序应抛出此类的实例以指示其他
空对象的非法用途。

也是这样的情况，如果您尝试使用同步的null引用，也会引发此例外， per jls ：

 同步：
    同步（表达式）块
 

• 否则，如果表达式的值为null，则抛出 nullpoInterException 。

我该如何修复？

因此，您有一个 nullpoInterException 。您如何修复它？让我们以一个简单的示例，该示例将 NullPoInterException ：

public class Printer {
    private String name;

    public void setName(String name) {
        this.name = name;
    }

    public void print() {
        printString(name);
    }

    private void printString(String s) {
        System.out.println(s + " (" + s.length() + ")");
    }

    public static void main(String[] args) {
        Printer printer = new Printer();
        printer.print();
    }
}

识别零值

第一步是确切地识别哪些值导致异常。为此，我们需要进行一些调试。学会阅读 stacktrace 很重要。这将向您展示抛出异常的位置：

Exception in thread "main" java.lang.NullPointerException
    at Printer.printString(Printer.java:13)
    at Printer.print(Printer.java:9)
    at Printer.main(Printer.java:19)

在这里，我们看到例外是在第13行上抛出的（在 printString 方法中）。查看该行并检查哪些值为null
添加记录语句或使用 debugger 。我们发现 s 是空的，并且在其上调用长度方法会引发异常。我们可以看到，当从该方法中删除 s.length（）时，程序停止抛出异常。

跟踪这些值来自

下一步检查此值的来源。通过遵循该方法的呼叫者，我们看到 s 在 printString（name）中传递给 print（）方法和<代码> this.name 为null。

跟踪应设置这些值的位置

this.name 设置在哪里？在 setName（string）方法中。有了更多的调试，我们可以看到这种方法根本没有调用。如果调用了该方法，请确保检查顺序是否调用了这些方法，并且在打印方法之后未称为 。

这足以给我们一个解决方案：在调用 printer.setName（）之前将调用添加到 printer.print.print（）之前。

其他修复程序

该变量可以具有默认值（和 setName 可以防止其设置为null）：

private String name = "";

print 或 printsring 方法

printString((name == null) ? "" : name);

：

public class Printer {
    private final String name;

    public Printer(String name) {
        this.name = Objects.requireNonNull(name);
    }

    public void print() {
        printString(name);
    }

    private void printString(String s) {
        System.out.println(s + " (" + s.length() + ")");
    }

    public static void main(String[] args) {
        Printer printer = new Printer("123");
        printer.print();
    }
}

另请参见：

• 避免使用java中的“！= null”语句？<<<<<<<<<<<<< /a>，

如果您尝试调试问题并且仍然没有解决方案，我仍然找不到问题

，您可以将问题发布更多帮助，但请确保包括到目前为止尝试的内容。至少，在问题中包含stacktrace ，在代码中标记重要的线号。另外，请尝试首先简化代码（请参阅 sscce ）。

Answer 4

问题：是什么原因导致 NullPoInterException （NPE）？

如您所知，Java类型被分为原始类型（ boolean ， int 等）和参考类型。 Java中的参考类型允许您使用特殊值 null ，这是Java说“无对象”的方法。

NullPoInterException 每当您的程序尝试使用 null 时，就会在运行时抛出，就像它是真正的参考。例如，如果您写下来：

public class Test {
    public static void main(String[] args) {
        String foo = null;
        int length = foo.length();   // HERE
    }
}

标记为“此处”的语句将尝试在 length（）方法上运行 null 参考，这将抛出<代码> NullPoInterException 。

您可以使用许多方法使用 null 值，该值将导致 nullpoInterException 。实际上，您可以使用 null 而不会导致NPE的唯一事情是：

• 将其分配给参考变量或从参考变量中读取它，
• 将其分配给数组元素或从数组元素读取它（规定数组引用本身是非null！），
• 将其作为参数传递或将其返回，或
• 使用 == 或！= 运算符，或实例。

问题：如何阅读NPE StackTrace？

假设我编译并运行上面的程序：

$ javac Test.java 
$ java Test
Exception in thread "main" java.lang.NullPointerException
    at Test.main(Test.java:4)
$

第一个观察：汇编成功！程序中的问题不是汇编错误。这是一个运行时错误。 （某些IDE可能会警告您的程序总是会抛出异常...但是标准 Javac 编译器不会。）

第二个观察：当我运行程序时，它输出了两行，“ Gobbledy-Gook ”。 错误！这是一个堆叠式...它提供重要信息，如果您花时间仔细阅读，它将帮助您跟踪代码中的错误。

因此，让我们看一下它说的内容：

Exception in thread "main" java.lang.NullPointerException

堆栈跟踪的第一行告诉您许多事情：

• 它告诉您抛出异常的Java线程的名称。对于一个带有一个线程的简单程序（像这样），它将是“主”。让我们继续前进...
• 它告诉您被抛出的例外的全名；即 java.lang.nullpointerexception 。
• 如果异常具有关联的错误消息，则将在异常名称之后输出。 NullPoInterException 在这方面是不寻常的，因为它很少有错误消息。

第二行是诊断NPE的最重要的一条线。

at Test.main(Test.java:4)

这告诉我们许多事情：

• “在test.main”中说我们在 main test 类的方法中。
• “ test.java：4”给出了类的源文件名，它告诉我们，此次发生的说明是在文件的第4行中。

如果您计算上面文件中的行，则第4行是我标记为“此处”注释的行。

请注意，在一个更复杂的示例中，NPE堆栈跟踪中将有很多行。但是，您可以确定第二行（第一行）将告诉您NPE被抛出 ¹ 。

简而言之，堆栈跟踪会明确地告诉我们该程序的哪种陈述已抛出了NPE。

另请参见：什么是堆栈跟踪，我该如何使用它来调试应用程序错误？

^{1-1-不太正确。有一些称为嵌套异常的东西...}

问题：如何跟踪代码中NPE异常的原因？

这是困难的部分。简短的答案是将逻辑推断应用于堆栈跟踪，源代码和相关API文档的证据。

让我们先用简单的示例（上）说明。我们首先要查看堆栈跟踪告诉我们的线路是NPE发生的位置：

int length = foo.length(); // HERE

如何抛出NPE？

实际上，只有一种方法：仅当 foo 具有值 null 时，才能发生。然后，我们尝试在 length（）方法上运行 null 和... bang！

但是（我听到您说）如果NPE被扔进 length（）方法调用中怎么办？

好吧，如果发生这种情况，堆栈跟踪看起来会有所不同。第一个“ at”行说，例外是在 java.lang.string 类和 test.java 的第4行中的某个行中抛出的。在“线”。

那么 null 从何而来？在这种情况下，这很明显，很明显，我们需要采取的措施来修复它。 （将非null值分配给 foo 。）

好的，让我们尝试一个更棘手的示例。这将需要一些逻辑扣除。

public class Test {

    private static String[] foo = new String[2];

    private static int test(String[] bar, int pos) {
        return bar[pos].length();
    }

    public static void main(String[] args) {
        int length = test(foo, 1);
    }
}

$ javac Test.java 
$ java Test
Exception in thread "main" java.lang.NullPointerException
    at Test.test(Test.java:6)
    at Test.main(Test.java:10)
$ 

因此，现在我们有两个“ AT”行。第一个是为了这条线：

return args[pos].length();

第二个是为此行的：

int length = test(foo, 1);
    

看第一行，那怎么会抛出NPE？有两种方法：

• 如果 bar的值是 null ，则 bar [pos] 将抛出NPE。
• 如果 bar [pos] 的值是 null ，则调用 length（）将抛出NPE。

接下来，我们需要弄清楚哪些情况解释了实际发生的情况。我们将从探索第一个开始：

bar 从哪里？它是 test 方法调用的参数，如果我们查看 test 的调用，我们可以看到它来自 foo 静态变量。此外，我们可以清楚地看到，我们将 foo 初始化为非零值。这足以暂时驳斥这一解释。 （从理论上讲，其他可能会更改 foo to null ...但这不是在这里发生的。）

那么我们的第二种情况呢？好吧，我们可以看到 pos 是 1 ，因此这意味着 foo [1] 必须为 null 。这可能吗？

确实是！这就是问题。当我们这样初始化时：

private static String[] foo = new String[2];

我们将 String [] 用两个元素分配给 null 。之后，我们没有更改 foo 的内容... foo [1] 仍然是 null 。

在Android上呢？

在Android上，追踪NPE的直接原因更简单。例外消息通常会告诉您您使用的和的null引用的（编译时间）类型和在投掷NPE时试图调用的方法。这简化了查明直接原因的过程。

但是另一方面，Android具有一些NPE的常见平台特异性原因。一个非常常见的是 getViewById 出乎意料地返回 null 。我的建议是搜索Q＆amp;关于意外 null 返回值的原因。

Answer 5

就像您正在尝试访问 null 的对象一样。请考虑下面的示例：

TypeA objA;

目前您只是声明这个对象，但不是初始化或实例化。每当您尝试访问其中的任何属性或方法时，它都会抛出 nullpoInterException ，这是有道理的。

也请参见下面的示例：

String a = null;
System.out.println(a.toString()); // NullPointerException will be thrown

Answer 6

当应用程序在需要对象的情况下，当应用程序尝试使用NULL时，将抛出NEULL指针异常。这些包括：

1. 调用 null 对象的实例方法。
2. 访问或修改 null 对象的字段。
3. 将 null 的长度拿去，好像是数组一样。
4. 访问或修改 null 的插槽，就好像它是一个数组一样。
5. 扔 null ，就好像它是可投掷的值一样。

应用程序应投掷此类实例，以指示 null 对象的其他非法用途。

参考：

Answer 7

null 指针是指无处不在的。当您取消指针 p 时，您说“给我存储在“ P”中的位置。 ，存储在 p 的位置是 ，您说的是“在位置'无处可去的数据，所以它显然无法做到这一点。它抛出 null指针异常

。

Answer 8

已经有很多解释来解释它是如何发生以及如何修复它的，但是您也应该遵循最佳实践避免 nullpointerexpiption

参见：
最佳实践

我会补充一点，非常重要，可以很好地利用 final 修饰符。
使用“最终”

修饰符：

1. 使用 final 修饰符来执行良好的初始化。
2. 避免在方法中返回null，例如适用时返回空收集。
3. 使用注释和 @Nullable
4. 快速失败，并使用断言在整个应用程序不应为null时避免通过整个应用程序传播Null对象。
5. 首先使用已知对象的平等： if（“ nownobject” .equals（unknownobject）
6. peave valueof（）而不是 toString（）。
7. 使用null SAFE 方法 stringutils.isempty（null）
8. 使用Java 8可选作为方法中的返回值，可选类为表示可选值而不是null引用提供了解决方案。

Answer 9

NULL指针异常是您使用对象而不初始化对象的指标。

例如，以下是一个学生课，它将在我们的代码中使用它。

public class Student {

    private int id;

    public int getId() {
        return this.id;
    }

    public setId(int newId) {
        this.id = newId;
    }
}

以下代码为您提供了空指针异常。

public class School {

    Student student;

    public School() {
        try {
            student.getId();
        }
        catch(Exception e) {
            System.out.println("Null pointer exception");
        }
    }
}

因为您正在使用 student ，但您忘了像在
正确的代码如下：

public class School {

    Student student;

    public School() {
        try {
            student = new Student();
            student.setId(12);
            student.getId();
        }
        catch(Exception e) {
            System.out.println("Null pointer exception");
        }
    }
}

Answer 10

在Java中，所有内容（不包括原始类型）都是类的形式。

如果要使用任何对象，则有两个阶段：

1. 声明
2. 初始化

示例：

• 声明： object;
• 初始化： object = new Object（）;

对于数组概念：

• 声明： item Item [] =新项目[5];
• 初始化： item [0] = new Item（）;

如果您不给出初始化部分，则 NullPoInterException 出现。

Answer 11

在 java 您声明的所有变量实际上是“参考”原语）而不是对象本身。

当您尝试执行一个对象方法时，参考要求生存对象执行该方法。但是，如果引用是引用null（零，零，void，nada），则无法执行该方法。然后，运行时让您通过扔一个NullPoInterException知道这一点。

您的引用是“指向” null，因此“指向”。

该对象生活在VM内存空间中，访问它的唯一方法是使用 this 引用。举此示例：

public class Some {
    private int id;
    public int getId(){
        return this.id;
    }
    public setId( int newId ) {
        this.id = newId;
    }
}

在您的代码中的另一个位置：

Some reference = new Some();    // Point to a new object of type Some()
Some otherReference = null;     // Initiallly this points to NULL

reference.setId( 1 );           // Execute setId method, now private var id is 1

System.out.println( reference.getId() ); // Prints 1 to the console

otherReference = reference      // Now they both point to the only object.

reference = null;               // "reference" now point to null.

// But "otherReference" still point to the "real" object so this print 1 too...
System.out.println( otherReference.getId() );

// Guess what will happen
System.out.println( reference.getId() ); // :S Throws NullPointerException because "reference" is pointing to NULL remember...

这是一个重要的事情 - 当不再对对象引用时（在上面的示例参考 and 其他retherference 两个指向null），然后该对象是“无法到达的”。我们无法使用它，因此该对象准备好收集垃圾，在某些时候，VM将释放此对象使用的内存并分配另一个。

Answer 12

当一个声明对象数组时，另一个出现 nullpoInterException 会发生，然后立即尝试在其内部的取消元素。

String[] phrases = new String[10];
String keyPhrase = "Bird";
for(String phrase : phrases) {
    System.out.println(phrase.equals(keyPhrase));
}

^{如果比较顺序相反，则可以避免此特定的NPE；也就是说，在保证的非零件对象上使用 .equals 。}

数组中的所有元素/se7/html/jls-4.html#jls-4.12.5“ rel =“ noreferrer”>被初始化为其共同的初始值 ;对于任何类型的对象数组，这意味着所有元素均为 null 。

您必须在访问或取消给它们之前初始化数组中的元素。

String[] phrases = new String[] {"The bird", "A bird", "My bird", "Bird"};
String keyPhrase = "Bird";
for(String phrase : phrases) {
    System.out.println(phrase.equals(keyPhrase));
}