空指针异常 订阅
空指针异常是指java中的异常类。 展开全文
空指针异常是指java中的异常类。
信息
外文名
NullPointerException
中文名
空指针异常
相对路径绝对路径和相对路径
当应用程序试图在需要对象的地方使用 null 时,抛出该异常。这种情况包括:应用程序应该抛出该类的实例,指示其他对 null 对象的非法使用。
收起全文
精华内容
下载资源
问答
  • Optional可以让你的代码具有可读性,且会避免出现空指针异常。下面这篇文章主要给大家介绍了关于利用Java8 Optional如何避免空指针异常的相关资料,文中通过示例代码介绍的非常详细,需要的朋友可以参考下。
  • 主要介绍了Java中避免空指针异常的方法,本文讨论Optional类型、Objects类等技术,需要的朋友可以参考下
  • 主要介绍了Java字符串比较方法equals的空指针异常的解决,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 日志级别导致Dubbo出现空指针异常,这个是在查看源码排查问题之后,反推得到的结论。 文章所用Dubbo版本为2.6.3 问题复现 Consumer A服务依赖Provider B服务。 Consumer A先启动了,此时注册中心无B服务实现,而后...
  • 今天小编就为大家分享一篇关于实例化JFileChooser对象报空指针异常问题的解决办法,小编觉得内容挺不错的,现在分享给大家,具有很好的参考价值,需要的朋友一起跟随小编来看看吧
  • Sqoop从MySQL导数据到HDFS上,如果报错空指针异常,需要的jar包。正常情况只要安装java-json.jar就可以。如果不行就都安装上。如果你用的是阿里云的EMR,安装完之后还报错的话,需求确认你的jar包中是否含有hive开头...
  • 提出一种空指针异常自动定位方法。该方法首先结合程序的静态分析技术,利用程序运行时的堆栈信息指导程序切片,然后对得到的切片进行空指针分析及别名分析,得出引发空指针异常的可疑语句集合,最终给出错误定位报告...
  • 空指针异常

    2013-05-22 20:20:06
    空指针异常进行举例,并对实例进行解释,
  • 下面小编就为大家带来一篇浅谈java异常处理之空指针异常。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • http://blog.csdn.net/zhufuing/article/details/27807813 博文演示demo Android setOnClickListener报空指针异常错误demo
  • Android 防止空指针异常

    千次阅读 2019-07-29 10:23:40
    文章目录空指针异常防止空指针异常Java 注解Java 8 中的 Optional 类型Kotlin总结 空指针异常 先复习下异常。 异常分为 Exception 和 Error,Exception 和 Error 类都继承自Throwable类。 Exception(程序可恢复)...

    空指针异常

    先复习下异常。

    异常分为 ExceptionError,Exception 和 Error 类都继承自Throwable类。

    • Exception(程序可恢复):表示程序可以处理的异常,可以捕获并且可恢复。遇到这类异常,应该尽可能处理异常,使程序恢复运行,而不应该随意终止异常。
    • Error(程序不可恢复):一般指虚拟机相关的问题,如系统崩溃,虚拟机错误,内存空间不足,方法调用栈溢出等。这于这类错误,Java编译器不去检查也会导致应用程序中断,仅靠程序本身无法恢复和预防,遇到这样的错误,建议程序终止。

    Exception 又分为运行时异常受检查的异常

    • 运行时异常:如空指针,参数错误等。
    • 受检查异常:这类异常如果没有try/catch语句也没有throws抛出,编译不通过。

    空指针异常(NullPointerException)属于运行时异常,当应用程序试图在需要对象的地方使用 null 时,抛出该异常。这种情况包括:

    • 调用 null 对象的实例方法。
    • 访问或修改 null 对象的字段。
    • 将 null 作为一个数组,获得其长度。
    • 将 null 作为一个数组,访问或修改其时间片。
    • 将 null 作为 Throwable 值抛出。

    遇到该异常,如果又没有try/catch语句,就将导致应用程序终止。从应用程序线上问题统计中发现,空指针异常是比较常见的。所以防止空指针异常非常有必要。


    防止空指针异常

    要防止空指针异常,可以从三方面来入手:

    1. Java 注解辅助
    2. 引入 Java 8 中的 Optional 类型
    3. 使用 Kotlin 区分可空类型和非空类型

    Java 注解

    Java 注解可以用来表达值的可空性,帮助静态扫描工具找到可能抛出 NullPointerException 的地方。

    Android 提供了可空注解@NonNull 和 非空注解@NonNull

        @Nullable
        public Fragment findFragment(@NonNull FragmentActivity activity, @NonNull String tag) {
            FragmentManager fragmentManager = activity.getSupportFragmentManager();
            return fragmentManager.findFragmentByTag(tag);
        }
    

    在使用者使用的时候,如果没有正确的使用可空类型和非空类型,就会得到编译器的提示:
    在这里插入图片描述
    在这里插入图片描述
    所以注解只能用来提示使用者在使用的时候是可空类型还是非空类型,但并不能限定使用者传递的是可空类型还是非空类型。

    Java 8 中的 Optional 类型

    Java 8 中引入了 Optional 类型,它是一个可能包含或不包含非空值的容器对象,用更优雅的方式来防止 NullPointerException

    Optional 类 提供的主要方法:

    方法名字表示意思
    of返回具有 Optional的当前非空值的Optional。
    ofNullable返回一个 Optional指定值的Optional,如果非空,则返回一个空的 Optional 。
    isPresent如果存在值,则返回 true ,否则为 false 。
    get如果 Optional中存在值,则返回值,否则抛出 NoSuchElementException 。
    map如果存在值,则应用提供的映射函数,如果结果不为空,则返回一个Optional结果的Optional 。 否则返回一个空的Optional 。
    flatMap如果一个值存在,应用提供的Optional映射函数给它,返回该结果,否则返回一个空的Optional 。 这种方法类似于map(Function) ,但是提供的映射器是一个结果已经是Optional映射器,如果被调用, flatMap不会用额外的Optional 。
    orElse返回值如果存在,否则返回 other 。

    测试例子:

    创建一个User类:

    public class User {
    	private String nickname;
    	private Address address;
    
    	public User() {
    	}
    
    	public Optional<Address> getAddress() {
    		return Optional.ofNullable(address);
    	}
    
    	public void setAddress(Address address) {
    		this.address = address;
    	}
    
    	public String getNickname() {
    		return nickname;
    	}
    
    	public void setNickname(String nickname) {
    		this.nickname = nickname;
    	}
    
    }
    

    获取 Nickname:

    	private String getUserNickname(User user) {
    		return Optional.ofNullable(user).map(new Function<User, String>() {
    
    			@Override
    			public String apply(User t) {
    				return t.getNickname();
    			}
    		}).orElse("default");
    	}
    	
    	String nickname = getUserNickname(null);
        //运行结果:nickname="default"
    

    ofNullable 方法主要将对象包装成一个Optional对象(用的就是组合):

    
        private static final Optional<?> EMPTY = new Optional<>();
    
        private final T value;
    
        private Optional() {
            this.value = null;
        }
    
        public static<T> Optional<T> empty() {
            @SuppressWarnings("unchecked")
            Optional<T> t = (Optional<T>) EMPTY;
            return t;
        }
    
        private Optional(T value) {
            this.value = Objects.requireNonNull(value);
        }
    
        public static <T> Optional<T> of(T value) {
            return new Optional<>(value);
        }
    
        public static <T> Optional<T> ofNullable(T value) {
            return value == null ? empty() : of(value);
        }
    

    map 方法会检测当前值是否为空,如果为空就返回一个空的Optional对象,否则将接口Function的回调方法apply的返回值包装成一个新的Optional对象。

        public boolean isPresent() {
            return value != null;
        }
    
        public <U> Optional<U> map(Function<? super T, ? extends U> mapper) {
            Objects.requireNonNull(mapper);
            if (!isPresent()) {
                return empty();
            } else {
                return Optional.ofNullable(mapper.apply(value));
            }
        }
    

    orElse 方法检测当前值是否为空,如果为空,就返回传入的默认值:

        public T orElse(T other) {
            return value != null ? value : other;
        }
    

    从上面可以 看出,使用 Optional 类,主要是将对象包装成 Optional 对象来防止 NullPointerException

    Optional 类 还可以解决在实际开过程中,经常遇到的一些链式调用引起的NullPointerException

    下面通过User 类,获取 Country 类 的属性,一般会这样写:

    		String countryName = null;
    		Address address = user.getAddress();
    		if(address!=null) {
    			Country country = address.getCountry();
    			if(country !=null) {
    				countryName = country.getName();
    			}
    		}
    

    上面代码中不得不对过程中遇到的每一个对象做判空处理,如果调用链很长,代码就会越不友好。修改user.getAddress()address.getCountry() 方法的返回值:

    	public Optional<Address> getAddress() {
    		return Optional.ofNullable(address);
    	}
    
    	public Optional<Country> getCountry() {
    		return Optional.ofNullable(country);
    	}
    

    使用Optional 类 ,将链式调用中遇到的任何一个对象都包装成 Optional对象:

    	private String  getCountryName(User user) {
    		return Optional.ofNullable(user).flatMap(new Function<User, Optional<Address>>() {
    
    			@Override
    			public Optional<Address> apply(User t) {
    				return t.getAddress();
    			}
    		}).flatMap(new Function<Address, Optional<Country>>() {
    
    			@Override
    			public Optional<Country> apply(Address t) {
    				return t.getCountry();
    			}
    		}).map(new Function<Country, String>() {
    
    			@Override
    			public String apply(Country t) {
    				return t.getName();
    			}
    		}).orElse("default");
    	}
    	
    	String countryName = getCountryName(user);
    	//运行结果:countryName = "default"
    

    在上面链式方法调用中,中间如果有任何一个对象为空,都不可能抛出空指针异常。

    虽然 Optional 可以防止NullPointerException,但是代码还是很冗长,并且额外的包装接口还会影响运行时的性能。

    Kotlin

    Kotlin 区分可空类型和非空类型,并会在编译期间对可空类型和非空类型检查。

    可空类型,问号添加在类型的后面表示这个类型的变量可以存储 null 引用:

        fun findFragment(activity: FragmentActivity?, tag: String?): Fragment? {
            val fragmentManager = activity?.supportFragmentManager
            return fragmentManager?.findFragmentByTag(tag)
        }
    

    如果没有正确使用,将得到编译器的错误提示,并无法编译:
    在这里插入图片描述
    非空类型,没有问号添加在类型的后面表示这个类型的变量不可以存储 null 引用:

        fun findFragment(activity: FragmentActivity, tag: String): Fragment? {
            val fragmentManager = activity.supportFragmentManager
            return fragmentManager?.findFragmentByTag(tag)
        }
    

    同样,如果没有正确使用,将得到编译器的错误提示,并无法编译:
    在这里插入图片描述
    可空类型和非空类型在运行时并没有什么区别,只是在编译期间对类型进行检查。所以,使用Kotlin 的可空类型并不会在运行时带来额外的开销。

    对于可空类型的判断,Kotlin 还提供了安全调用运算符?.Elvis 运算符?:安全转换符as?非空断言!!来防止空指针异常,这里不再一一介绍。


    总结

    防止空指针异常,有三种方法:使用Java 注解辅助,引入 Java 8 中的 Optional 类型, 使用 Kotlin 区分可空类型和非空类型。使用Java 注解辅助,只能提示使用者在使用的时候是可空类型还是非空类型,并不能限定使用者传递的是可空类型还是非空类型;引入 Java 8 中的 Optional 类型,能防止空指针异常,但是代码还是很冗长,并且额外的包装接口还会影响运行时的性能;使用 Kotlin 区分可空类型和非空类型,会在编译期间对类型进行检查,并且不会在运行时带来额外的开销。总之,使用 Kotlin 是防止空指针异常的最好方式。

    展开全文
  • java空指针异常:预防及解决办法

    千次阅读 2020-02-11 11:26:27
    这是我16年在博客园发的一篇博客,彼时还在学校。...空指针就是空引用,java空指针异常就是引用本身为空,却调用了方法,这个时候就会出现空指针异常。可以理解,成员变量和方法是属于对象的(除...

     

    一.什么是java空指针异常

        我们都知道java是没有指针的,这里说的"java指针"指的就是java的引用,我们不在这里讨论叫指针究竟合不合适,而只是针对这个异常本身进行分析。空指针就是空引用,java空指针异常就是引用本身为空,却调用了方法,这个时候就会出现空指针异常。可以理解,成员变量和方法是属于对象的(除去静态),在对象中才存在相对应的成员变量和方法,然后通过对象去调用这些成员变量和方法。对于空指针来说,它不指向任何对象,也就没有所谓的成员变量和方法,这个时候用它去调用某些属性和方法,当然会出现空指针异常。

    public class Test {
        private int a=1;
        private int b=2;
        public static void main(String[] args) {
            // TODO Auto-generated method stub
            Test t1 = new Test();
            Test t2 = null;
            System.out.println(t1.a);
            System.out.println(t2.a);
            System.out.println(t2.c());
        }
        public String c(){
            return "123";
        }
    }

    我们分析上面这段示例代码,在Test类中,有两个成员变量a和b,和一个方法c()。然后在main()方法中,我们创建了两个对象t1和t2,其中t1指向通过构造方法实例出的Test对象,而t2只是声明,并指向了空,并没有指向实际的对象。调试的时候,第一条输出语句是可以通过编译的,而执行到第二条输出语句的时候,由于空指针调用了不属于它的a,程序终止,报告空指针异常。同样,注释第二条输出语句,程序在执行到第三条输出语句的时候,由于调用了不属于它的c()方法,会出现一样的错误。

     

    二.如何解决

        对于每一个java程序员来说,几乎都避免不了遇到空指针异常,特别是经验不足的初学者。而且由于它的调试和查找相对其它异常来说比较困难,常常需要花费很大的精力去解决它。

        知己知彼,才能百战不殆。

        首先认识一下java中的null

        null是Java中一个很重要的概念。null设计初衷是为了表示一些缺失的东西,例如缺失的用户、资源或其他东西。但是,一年后,令人头疼的空指针异常给Java程序员带来不少的骚扰。

        null是java中的关键字,因此,它不能写成NULL,Null,只能是null。

        null是所有引用类型的默认值,如果没有让一个引用指向一个实际存在的对象,它的默认值就是null。null本质上是一个值,这跟int的默认值是0,boolean的默认值是false一样。现在,我们通常都使用像eclipse、idea等的集成开发环境进行开发,一般在定义变量的时候都会进行初始化(这也是写代码的一个良好的习惯),如果没有进行初始化,系统会进行提示。

    报空指针异常的原因有以下几种: 

    1、字符串变量未初始化; 
    2、接口类型的对象没有用具体的类初始化,比如: 
    List it;会报错 。(当时,eclipse等确实会对这行代码报错,现在又试了一下,不初始化也不报错了
    List it = new ArrayList();则不会报错了 
    3、当一个对象的值为空时,你没有判断为空的情况。你可以试着把下面的代码前加一行代码: 
    if(rb!=null && rb!="") 
    改成: 
    if(rb==null); 
    if(rb!==null&&rb!="") 或者if("").equals(rb)) 
    空指针的解决办法: 
           解决空指针问题的核心是找到“谁是空”,“为什么产生了空”。重点关注报错发生的所在行,通过空指针异常产生的两条主要原因诊断具体的错误。同时为了避免空指针的发生,最好在做判断处理时将“null”或者空值放于 设定的值之前。 
    常见空指针异常的简要分析: 
    (1)空指针错误 
        Java中的8种基本数据类型,变量的值可以有其默认值,加入没有对其正常赋值,java虚拟机是不能 正确编译通过的,因此使用基本的Java数据类型一般是不会引起空指针异常的。实际开发中,大多数的空指针异常主要与对象的操作相关。 
        下面列出可能发生空指针异常的几种情况及相应解决方案: 
        代码段1: 
      out.println(request.getParameter("username")); 
      分析:代码段1的功能十分简单,就是输出用户输入"username"的值。 
           说明:看上去,上面的语句找不出什么语法错误,而且在大多数情况下也遇不到什么问题。但是,如果某个用户在输入数据时并没有提供表单 域"username" 的值,或通过某种途径绕过表单直接输入时,此request.getParameter("username")的值为空(注意不是空字符串,是空对象 null。),out对象的println方法是无法直接对空对象操作的,因此代码段1所在的JSP页面将会抛出 "Java.lang.NullPointerException"异常。而且即使对象可能为空时,也调用Java.lang.Object或 Object对象本身的一些方法如toString(), equal(Object obj)等操作。 
        代码段2: 
      String userName = request.getParameter("username"); 
      If (userName.equals("root")) 
      {....} 
      分析:代码段2的功能是检测用户提供的用户名,如果是用户名称为"root"的用户时,就执行一些特别的操作。                                                                        
          说明:在代码段2中,如果有用户没有提供表单域"username"的值时,字符串对象userName为null值,不能够将一个null的对象与另一 个对象直接比较,同样,代码段2所在的JSP页面就会抛空指针错误。 
         一个小技巧,也几乎是实际开发中所有字符串比较采取的方法:如果要把某个方法的返回值与常量做比较,把常量放在前面,可以避免调用null对象的equals方法。譬如:  
        If ("root".equals(userName)) 
      {....} 
        即使userName对象返回了null对象,这里也不会有空指针异常,可以照常运转。 
        代码段3: 
      String userName = session.getAttribute("session.username").toString(); 
            分析:代码段3的功能是将session中session.username的值取出,并将该值赋给字符串对象userName。 
           说明:在一般情况下,如果在用户已经进行某个会话,则不会出现什么问题;但是,如果此时应用服务器重新启动,而用户还没有重新登录,(也可能是用户关闭浏 览器,但是仍打开原来的页面。)那么,此时该session的值就会失效,同时导致session中的session.username的值为空。对一个 为 null的对象的直接执行toString()操作,就会导致系统抛出空指针异常。 
        代码段4: 
    public static void main(String args[]){ 
           Person p=null; 
           p.setName("张三"); 
           System.out.println(p.getName()); 

    分析:声明一个Person对象,并打印出该对象的中的Name名字。 
    说明:这个时候你的p就出现空指针异常,因为你只是声明了这个Person类型的对象并没有创建对象,所以它的堆里面没有地址引用,切忌你要用对 象掉用方法的时候一定要创建对象。

     

     

       

     

    展开全文
  • Java空指针异常的几种情况

    千次阅读 2020-05-11 23:42:44
    Java空指针异常的几种情况 NullPointerException 说法一 NullPointerException由RuntimeException派生出来,是一个运行级别的异常。意思是说可能会在运行的时候才会被抛出,而且需要看这样的运行级别异常是否会...

                              Java空指针异常的几种情况

    NullPointerException

    说法一

    NullPointerException由RuntimeException派生出来,是一个运行级别的异常。意思是说可能会在运行的时候才会被抛出,而且需要看这样的运行级别异常是否会导致你的业务逻辑中断。

    编程语言中的空指针异常。

    1 当应用程序试图在需要对象的地方使用 null 时,抛出该异常。这种情况包括:

    • 调用 null 对象的实例方法。

    • 访问或修改 null 对象的字段。

    • 将 null 作为一个数组,获得其长度。

    • 将 null 作为一个数组,访问或修改其时间片。

    • 将 null 作为 Throwable 值抛出。

    出现在任何一个位置上的对象引用都有可能为 null,在进行访问,赋值,取值,类型转换等操作时,首先判断该对象是否为 null,否则极易抛出空指针异常; 

    2 比如变量为空,而你没有去判断,就直接使用,就会出现NullPointException。写程序时严谨些,尽量避免了,例如在拿该变量与一个值比较时,要么先做好该异常的处理如: if (str == null) {   System.out.println("字符为空!"); } 当然也可以将这个值写在前面进行比较的,例如,判断一个String的实例s是否等于“a”,不要写成s.equals("a"),这样写容易抛出NullPointerException,而写成"a".equals(s)就可以避免这个问题。不过对变量先进行判空后再进行操作比较好

     

     

    说法二

    1. Calling the instance method of a null object. 
    2. Accessing or modifying the field of a null object. 
    3. Taking the length of null as if it were an array. 
    4. Accessing or modifying the slots of null as if it were an array. 
    5. Throwing null as if it were a Throwable value. 

    -------------------------
     

    1:NullPointerException由RuntimeException派生出来,是一个运行级别的异常。意思是说可能会在运行的时候才会被抛出,而且需要看这样的运行级别异常是否会导致你的业务逻辑中断。
     2:空指针异常发生在对象为空,但是引用这个对象的方法。例如: String s = null; //对象s为空(null) int length = s.length();//发生空指针异常  
     3:一个变量是null,及只有其名,没有实值内容,也没分配内存,当你要去取他的长度,对他进行操作就会出现NullPointException,所以生命一个变量时最好给它分配好内存空间,给予赋值。  
      4:比如变量为空,而你没有去判断,就直接使用,就会出现NullPointException。写程序时严谨些,尽量避免了,例如在拿该变量与一个值比较时,要么先做好该异常的处理如: if (str == null) {   System.out.println("字符为空!"); } 当然也可以将这个值写在前面进行比较的,例如,判断一个String的实例s是否等于“a”,不要写成s.equals("a"),这样写容易抛出NullPointerException,而写成"a".equals(s)就可以避免这个问题。不过对变量先进行判空后再进行操作比较好  
     5:尽量避免返回null,方法的返回值不要定义成为一般的类型,而是用数组。这样如果想要返回null的时候,就返回一个没有元素的数组。就能避免许多不必要的NullPointerException,使用NullObject返回代替返回null确是一种不错的选择。 

     

    如何避免空指针?

    1、字符串比较,常量放前面

    if(status.equals(SUCCESS)){
    
    }
    这个时候 status 可能为 null 造成空指针异常,应该把常量放前面,就能避免空指针异常。
    
    if(SUCCESS.equals(status)){
    
    }

    2、初始化默认值

    在对象初始化的时候给它一个默认值或者默认构造实现,如:
    
    User user = new User();
    String name = StringUtils.EMPTY;

    3、返回空集合

    在返回一个集合的话,默认会是 null,统一规范返回一个空集合。
    
    举个 List 例子,如:
    
    public List getUserList(){
        List list = userMapper.gerUserList();
        return list == null ? new ArrayList() : list;
    }
    这样接收方就不用担心空指针异常了,也不会影响业务。

    4、断言

    断言是用来检查程序的安全性的,在使用之前进行检查条件,如果不符合条件就报异常,符合就继续。

    Java 中自带的断言关键字:assert,如:

    assert name == null : "名称不能为空";
    输出:
    
    Exception in thread "main" java.lang.AssertionError: 名称不正确
    不过默认是不启动断言检查的,需要要带上 JVM 参数:-enableassertions 才能生效。
    
    Java 中这个用的很少,建议使用 Spring 中的,更强大,更方便好用。
    
    Spring中的用法:
    
    Assert.notNull(name,"名称不能为空");

    5、Optional

    Optional 是 JDK 8 新增的新特性,再也不用 != null 来判断了,这个在一个对象里面的多个子对象连续判断的时候非常有用。

    这里不再详细介绍了,具体看这篇文章:JDK8新特性之Optional

    在这里插入图片描述

    展开全文
  • 已通过测试 调用方法如下 public static void main(String[] args) { EChannel test = new EChannel(); test.setBizType("12321");...biztype不会被修改,调用其他属性会报空指针的属性将被附上初始值
  • java空指针异常解决Java programming language provides the Null Pointer Exception type in order to handle object creation related errors and misuse. In this tutorial, we will learn what is Null Pointer ...
    java空指针异常解决

    java空指针异常解决

    Java programming language provides the Null Pointer Exception type in order to handle object creation related errors and misuse. In this tutorial, we will learn what is Null Pointer Exception, its causes and How To Fix it?

    Java编程语言提供了Null Pointer Exception类型,以处理与对象创建相关的错误和滥用。 在本教程中,我们将学习什么是空指针异常,其原因以及如何解决?

    空指针异常 (Null Pointer Exception)

    Java is an object-oriented programming language. Java provides different objects in order to create and use. In order to use an object, it should be initialized properly. If the object not initialized properly and try to be used it will throw a Null Pointer Exception.

    Java是一种面向对象的编程语言。 Java提供了不同的对象以便创建和使用。 为了使用对象,应正确初始化。 如果对象未正确初始化并尝试使用,则将抛出Null Pointer Exception。

    In the following code, we define an Integer object with the variable name num.  Then we initialize it with the new Integer(10) line. If we do not initialize the variable num and try to use it we will get a Null Pointer Exception.

    在下面的代码中,我们使用变量名num定义一个Integer对象。 然后,我们使用new Integer(10)行对其进行初始化。 如果我们不初始化变量num并尝试使用它,我们将得到一个Null Pointer Exception。

    class HelloWorld
    {
            public static void main(String args[])
            {
                    Integer num = null;
    
                    int new_var = num.intValue() ;
    
                    System.out.println(new_var);
            }
    }
    

    We can see that the following information about the null pointer exception is provided when the exception is thrown.

    我们可以看到抛出异常时提供了有关空指针异常的以下信息。

    • `Thread name` is the thread name where the exception occurred.

      “线程名”是发生异常的线程名。
    • `Exception type` is the exception name with the full class name which is `java.lang.NullPointerException` in this example.

      “异常类型”是具有完整类名的异常名称,在本示例中为“ java.lang.NullPointerException”。
    • `The class name` where the name of the class where the exception occurred which is `HelloWorld` in this example.

      “类名”是发生异常的类的名称,在此示例中为“ HelloWorld”。
    • `The function name` is the function name where the exception occurred which is `main` in this example.

      “函数名”是发生异常的函数名,在本示例中为“ main”。
    • `The line number` is the source code line number where the exception occurred which is 9 in this case.

      “行号”是发生异常的源代码行号,在这种情况下为9。

    空指针异常的原因 (Causes Of Null Pointer Exception)

    Null pointer exception can occur in different ways with different causes. But we can list them like below in general.

    空指针异常可能以不同的方式以不同的原因发生。 但是我们可以像下面一般列出它们。

    • Calling the instance method of a null object.

      调用空对象的实例方法。
    • Accessing or modifying the field or a null object.

      访问或修改字段或空对象。
    • Taking the length of the null as if it were an array.

      以null的长度作为数组。
    • Accessing or modifying the slots of null as if it were an array.

      访问或修改null插槽,就好像它是一个数组一样。
    • Throwing null as if it were a Throwable value.

      将null视为Throwable值。
    LEARN MORE  Python "with" Statement By Examples
    通过示例了解更多Python“ with”语句
    Causes Of Null Pointer Exception
    Causes Of Null Pointer Exception
    空指针异常的原因

    空指针异常的解决方案(Solutions For Null Pointer Exception)

    The null pointer exception can be fixed or solved just by properly initializing the given object which will set an instance for the object. So the object will have an instance and will not null which is the cause of the Null Pointer Exception. In the following example, we will initialize the variable named num which is an Integer type.

    空指针异常可以通过适当地初始化给定对象(该对象将设置该对象的实例)来解决或解决。 因此,该对象将具有一个实例,并且不会为null,这是Null Pointer Exception的原因。 在下面的示例中,我们将初始化名为num的变量,它是一个Integer类型。

    class HelloWorld
    {
            public static void main(String args[])
            {
                    Integer num = 10;
    
                    int new_var = num.intValue() ;
    
                    System.out.println(new_var);
            }
    }
    

    翻译自: https://www.poftut.com/what-is-null-pointer-exception-in-java-and-how-to-fix/

    java空指针异常解决

    展开全文
  • 主要介绍了Java8新特性之空指针异常的克星Optional类的实现,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • java避免空指针异常 空指针异常是Java中最常见,最烦人的异常。 在这篇文章中,我想避免这种不希望的异常。 首先让我们创建引发空指针异常的示例 private Boolean isFinished(String status) { if (status....
  • 空指针异常原因分析

    2021-03-22 10:35:29
    定义首先介绍一下空指针异常的定义:空指针异常(NullPointerException):空指针异常是指java中的异常类,当应用程序试图在需要对象的地方使用 null 时,就会抛出该异常.简而言之,就是当你要使用一个对象时,结果对象并无...
  • 程序中抛出空指针异常 这篇文章简要介绍了Java 8的最有用但又“毫不夸张”的功能。 程序员花费了无尽的时间来纠正最常见但最危险的错误之一,即Null指针异常。 空指针异常会导致我们的应用程序意外中断,并且...
  • 空指针异常堆栈图.png

    2021-03-10 16:54:41
    关于空指针异常的简述图
  • java空指针异常-解决办法

    千次阅读 2019-09-09 15:45:53
    空指针异常一般都是由于没有对创建的对象进行初始化,即指向的对象为空(null),当操作这个对象时,就会报空指针异常。当操作一个对象不存在的方法时,也会报空指针异常。 解决办法:根据报错信息,检查设置的对象...
  • 空指针异常主要原因以及解决方案

    万次阅读 2020-03-23 00:14:44
    空指针异常产生的主要原因如下: (1)当一个对象不存在时又调用其方法会产生异常obj.method() // obj对象不存在 (2)当访问或修改一个对象不存在的字段时会产生异常obj.method() // method方法不存在 (3)字符串...
  • 空指针异常是什么意思?        这里我们首先要明确什么是指针,指针指的是什么? 指针:我所理解的指针指的是java程序中的对象 那什么是空?      &...
  • 空指针异常 NullPointException

    千次阅读 2019-08-26 23:00:11
    空指针异常 NullPointException 空指针异常,是运行时异常,及时编写代码时出现了空指针异常,编译器(javac) 会编译通过不报错,但是运行时Runtime阶段会抛出NullPointException 一.空指针异常可能的情况 1.调用null...
  • 空指针异常如何避免,听听老司机分享一些条件反射式的使用经验。
  • Android-Application被回收引发空指针异常分析(消灭全局变量)-例子 http://blog.csdn.net/zivensonice/article/details/51451486
  • list.size 前需要判断list是否为null,为空报空指针 类型转换时,提前判断要转换的对象是否可能为null ...调外部接口时,一定要加try/catch,不然别人接口挂了,你的接口获取不到数据也可能 空指针异常 ...
  • java 避免空指针异常

    千次阅读 2018-07-05 18:17:37
    Java应用中抛出的空指针异常是解决空指针的最好方式,也是写出能顺利工作的健壮程序的关键。熟话说“预防胜于治疗”,对于这么令人讨厌的空指针异常,这句话也是成立的。值得庆幸的是运用一些防御性的编码技巧,跟踪...
  • Java应用中抛出的空指针异常是解决空指针的最好方式,也是写出能顺利工作的健壮程序的关键。 避免Java中的空指针异常的常用技巧(同时避免大量的非空检查): 1) 从已知的String对象中调用equals()和...
  • 空指针异常排查

    2020-09-08 11:48:09
    空指针异常就是某个操作产生的结果为空(null),为空的话是不能进行其他操作。 排查空指针其实有几个比较常见的场景,也是比较容易犯错的。 1)查询的对象为null,然后进行get操作(最常见的是从数据库查询一个实体...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 223,550
精华内容 89,420
关键字:

空指针异常