Maison > Questions et réponses > le corps du texte
P粉2521165872023-08-24 09:14:35
NullPointerException
是当您尝试使用指向内存中任何位置 (null) 的引用时发生的异常,就像引用对象一样。对空引用调用方法或尝试访问空引用的字段将触发 NullPointerException
。这些是最常见的,但 中列出了其他方法NullPointerException
page javadoc.
L'exemple de code le plus rapide auquel je puisse penser pour illustrer une NullPointerException est probablement :
public class Example { public static void main(String[] args) { Object obj = null; obj.hashCode(); } }
dans main
内的第一行,我显式地将 Object
引用 obj
设置为 null
。这意味着我有一个引用,但它没有指向任何对象。之后,我尝试通过调用该引用的方法来将该引用视为指向一个对象。这会导致 NullPointerException
car il n'y a pas de code à exécuter à l'emplacement pointé par la référence.
(C'est une question technique, mais je pense que cela vaut la peine de le mentionner : une référence à null n'est pas la même chose qu'un pointeur C pointant vers un emplacement mémoire invalide. Un pointeur nul ne pointe nulle part , ce qui est la même chose comme pointant vers un emplacement qui s'avère être invalide. Différence subtile)
P粉5935361042023-08-24 00:10:48
Il existe deux principaux types de variables en Java :
Primitives : Variables contenant des données. Si vous souhaitez manipuler les données de la variable d'origine, vous pouvez manipuler la variable directement. Par convention, les types primitifs commencent par une lettre minuscule. Par exemple, les variables de type int
或 char
sont des primitives.
Référence : Une variable contenant l'adresse mémoire d'un Objet
, c'est-à-dire une variable qui 对象
内存地址的变量,即引用对象的变量代码>.如果您想要操作引用变量引用的Object
,则必须取消引用它。取消引用通常需要使用 .
访问方法或字段,或使用 [
索引数组。按照惯例,引用类型通常用以大写字母开头的类型来表示。例如,Object
référence à un
. >Objet
référencé par le code variable de référence>, vous devez le le. Le déréférencement nécessite généralement l'utilisation de .
pour accéder à une méthode ou à un champ, ou de [
pour indexer un tableau. Par convention, les types référence sont généralement représentés par le type commençant par une lettre majuscule. Par exemple, les variables de type Object
sont des références. int
rawx
指定任何值,而我们正在尝试使用 x
的值来指定 y
de type
int x;
int y = x + x;
Ces deux lignes feront planter le programme car il n'y a pas de >. Toutes les primitives doivent être initialisées à des valeurs utilisables avant de pouvoir être manipulées. null
,这意味着“我没有引用任何东西”。如果您以这种方式显式设置引用变量,则可以在引用变量中获取 null
值,或者引用变量未初始化并且编译器不会捕获它(Java 会自动将该变量设置为 null
Maintenant, les choses deviennent intéressantes. RéférencesLes variables peuvent être définies sur null
, ce qui signifie "Je ne fais référence à rien ". Si vous définissez explicitement une variable de référence de cette manière, vous pouvez obtenir une valeur null
dans la variable de référence, ou la variable de référence n'est pas initialisée et le compilateur ne l'attrape pas (Java définit automatiquement la variable à null
). NullPointerException
de la déréférencer NullPointerException
, vous obtiendrez un
se produit généralement lorsque vous déclarez une variable mais que vous ne créez pas et n'attribuez pas l'objet à la variable avant d'essayer d'utiliser le contenu de la variable
(NPE). Vous faites donc référence à quelque chose qui n’existe pas réellement. num
的变量,但它实际上还不包含引用值。由于您还没有说出要指向什么,Java 将其设置为 null
Integer num; num = new Integer(10);
new
关键字用于实例化(或创建)一个Integer
类型的对象,引用变量num
被分配给该 Integer
La première ligne déclare un fichier nommé .
num
,,您将得到一个NullPointerException
。在最简单的情况下,编译器会捕获问题并让您知道“num 可能尚未初始化
Deuxième ligne,
Si vous essayez de déréférencer
num
avant de créer l'objet, obj
,而是假设它是在调用 doSomething()
vous obtiendrez un
num n'a peut-être pas été initialisé
", mais parfois vous pouvez écrire du code qui ne crée pas directement l'objet. 🎜
🎜Par exemple, vous pourriez avoir la méthode suivante : 🎜
public void doSomething(SomeObject obj) { // Do something to obj, assumes obj is not null obj.myMethod(); }🎜Dans ce cas, vous ne créez pas l'objet qui a été créé avant la méthode 🎜. Notez que la méthode peut être appelée comme ceci : 🎜
doSomething(null);
Dans ce cas, obj
为 null
,并且语句 obj.myMethod()
将抛出 NullPointerException
>.
Si la méthode a l'intention d'effectuer une opération sur l'objet transmis comme la méthode ci-dessus, lancer NullPointerException
est approprié car il s'agit d'une erreur du programmeur et le programmeur a besoin de ces informations à des fins de débogage.
En plus des NullPointerException
异常之外,您还可以检查方法参数中的 null
exceptions levées en raison de la logique de la méthode, vous pouvez également vérifier la valeur
// Throws an NPE with a custom error message if obj is null Objects.requireNonNull(obj, "obj must not be null");Notez qu'il serait utile d'indiquer explicitement quel
null
objet ne peut pas être dans le message d'erreur. Les avantages de cette validation sont que 1) vous pouvez renvoyer votre propre message d'erreur plus clair, 2) pour le reste de la méthode, vous savez qu'à moins que obj ne soit réaffecté, il n'est pas nul et peut être déréférencé en toute sécurité .
Alternativement, dans certains cas, le but de la méthode n'est pas seulement d'opérer sur l'objet transmis, donc un paramètre vide peut être acceptable. Dans ce cas, vous devez vérifier le paramètre nuldoSomething()
et vous comporter différemment. Vous devez également expliquer cela dans la documentation. Par exemple,
/** * @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 } }Enfin, Comment utiliser les traces de pile pour identifier les exceptions et les causes
Maintenant, Java 14 ajoute une nouvelle fonctionnalité de langage pour afficher la cause première de NullPointerException. Cette fonctionnalité linguistique fait partie de SAP Business JVM depuis 2006.
En Java 14, voici un exemple de message d'exception NullPointerException :
NullPointerException
Liste des situations qui provoquent que
NullPointerException
Voici toutes les situations où
抛出空值;
synchronized (someNullReference) { ... }
Sync sur null - NullPointerException
Tout opérateur entier/virgule flottante peut être lancé si l'un de ses opérandes est une référence nulle encadrée NullPointerException
La conversion de déballage augmente super
会引发 NullPointerException
Appeler super
sur une référence nulle augmente class Outer { class Inner {} } class ChildOfInner extends Outer.Inner { ChildOfInner(Outer o) { o.super(); // if o is null, NPE gets thrown } }
for (element : iterable)
Utilisez
switch (foo) { ... }
(无论是表达式还是语句)在 foo
时可以抛出 NullPointerException
est vide.
foo.new SomeInnerClass()
当 foo
为 null 时抛出 NullPointerException
.
name1::name2
或 primaryExpression::name
形式的方法引用在以下情况下求值时会抛出 NullPointerException
name1 或 primaryExpression
est évalué à null.
La note de JLS indique que someInstance.someStaticMethod()
不会抛出 NPE,因为 someStaticMethod
是静态的,但 someInstance:: someStaticMethod
lance toujours du NPE !
* Attention, JLS peut aussi indirectement parler beaucoup de NPE.