程序博客网 > 民用枪持枪证 知乎

java笔试题及解答专辑201710241407

来源：互联网 发布：民用枪持枪证 知乎 编辑：程序博客网 时间：2024/05/21 17:30

具体题目记不清楚了，题目问的是将一个空引用转换为本类引用然后调用方法，判断执行结果。 
个人感觉这其实跟c/c++的空指针相似 
直接上测试代码

public class Main {    public static void main(String[] args) {        try {            ((Main) null).teststaticNull();        } catch (NullPointerException e) {            System.out.println("null can not invoke static methood");        }        try {            ((Main) null).testnormalNull();        } catch (NullPointerException e) {            System.out.println("null can not invoke normal methood");        }    }    private static void teststaticNull() {        System.out.println("null can invoke static methood");    }    private void testnormalNull() {        System.out.println("null can invoke normal methood");    }}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23

输出结果

null can invoke static methoodnull can not invoke normal methood
  • 1
  • 2

打开.class文件可以看到代码变成了

public static void main(String[] args) {        try {            Main var10000 = (Main)null;            teststaticNull();        } catch (NullPointerException var3) {            System.out.println("null can not invoke static methood");        }        try {            ((Main)null).testnormalNull();        } catch (NullPointerException var2) {            System.out.println("null can not invoke normal methood");        }    }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

道理很简单，static方法属于类，null调用static方法实际上是并不需要经过对象，相当于直接调用静态方法，在编译的时候就对象被擦除了。所以第一个输出是这样的。 
而实例方法是属于对象的。null在堆中并没有内存，并没有方法，Jvm通过反射invoke method时找不到就出现了我们看到的空引用异常。

补充

在Java Spec里面对null的说明如下：

  • JLS 4.1 The Kinds of Types and Values

There is also a special null type, the type of the expression null, which has no name. Because the null type has no name, it is impossible to declare a variable of the null type or to cast to the null type. The null reference is the only possible value of an expression of null type.The null reference can always be assigned or cast to any reference type. In practice, the programmer can ignore the null type and just pretend that null is merely a special literal that can be of any reference type. 
有一个特殊的null类型，他没有名字，所以不能声明null类型变量，也不能成为被转换的对象。一个null类型表达式的唯一可能值就是空引用。null引用可以被任何引用类型赋值或者转换为任何引用类型。 
最佳实践：程序员可以忽略null类型，把他当成可以是任何引用类型的字面量即可。

  • Java Spec 2.4. Reference Types and Values 
    null标识一个不指向任何对象的引用，空引用没有运行时类型，但是能被转换为任意引用类型，引用类型的默认值就是null。 
    Java Spec没有规定如何对null编码。 
    参考：http://stackoverflow.com/questions/2707322/what-is-null-in-java 
    注意：不要将null赋值给基本类型，同时注意null的包装类自动拆箱给基本类型会产生空指针异常。

null与instanceof 
Java tutorial里面有句话 
When using the instanceof operator, keep in mind that null is not an instance of anything. 
null并不是任何Object的实例 
所以null instanceof Object的结果永远是false。

null与== 
Java Spec里面也有写 
null==null返回true； 
null与Map 
HashMap支持null作为key，Hashtable不支持。 
null最佳实践 
用null去标识 
1.未初始化的状态 
2.终结状态（IO相关） 
3.不存在对象 
4.未知的值

处理空指针异常

一般方式

if(object !=  null){    //doSomething();}else{    //doOtherthing();}
  • 1
  • 2
  • 3
  • 4
  • 5

虽然看起来并不怎么舒服，但是也是可以处理的。一层还算好，要是几层下来的话，代码可读性就相当差了 
http://stackoverflow.com/questions/271526/avoiding-null-statements里面几种处理方式可以一试 
1.Assert 
2.try/catch 
3.使用注解@NotNull

Java8的Optional

oracle的technetwork有篇文章介绍了用法 
Tired of Null Pointer Exceptions? Consider Using Java SE 8’s Optional! 
国内译文 
具体用法上面文章已经很清楚了。我这边就不介绍了。

总结：其实想想都会觉得简单，也就是类方法与实例方法的区别而已，只是在笔试中心态不够好。

　Java虚拟机通过装载、连接、初始化来使得一个Java类型可以被Java程序所使用，如下图所示，其中连接过程又分为验证、准备、解析三个部分。其中部分类的解析过程可以推迟到程序真正使用其某个符号引用时再去解析。
这里写图片描述
解析过程可以推迟到类的初始化之后再进行，但这是有条件的，Java虚拟机必须在每个类或接口主动使用时进行初始化。
以下为主动使用的情况：
(1).(无论直接通过new创建出来的，还是通过反射、克隆、序列化创建的)创建某个类新的实例
(2).使用某个类的静态方法
(3).访问某个类或接口的静态字段
(4).调用JavaAPI中的某些反射方法
(5).初始化某个类的子类(要求其祖先类都要被初始化，否则无法正确访问其继承的成员)
(6).启动某个标明为启动类的类(含有main()方法)
主动使用会导致类的初始化，其超类均将在该类的初始化之前被初始化，但通过子类访问父类的静态字段或方法时，对于子类(或子接口、接口的实现类)来说，这种访问就是被动访问，或者说访问了该类(接口)中的不在该类(接口)中声明的静态成员。
如：
Grandpa的定义如下：

[java] view plain copy
  1. package com.ice.passiveaccess;  
  2.   
  3. public class Grandpa {  
  4.     static{  
  5.         System.out.println("Grandpa was initialized.");  
  6.     }  
  7. }  

Parent的定义如下：

[java] view plain copy
  1. package com.ice.passiveaccess;  
  2.   
  3. public class Parent extends Grandpa{  
  4.     static String language = "Chinese";  
  5.     static{  
  6.         System.out.println("Parent was initialized.");  
  7.     }  
  8. }  


Cindy的定义如下：

[java] view plain copy
  1. package com.ice.passiveaccess;  
  2.   
  3. public class Cindy extends Parent{  
  4.     static{  
  5.         System.out.println("Child was initialized.");  
  6.     }  
  7. }  


现在通过Cindy访问父类的language成员

[java] view plain copy
  1. package com.ice.passiveaccess;  
  2.   
  3. public class PassiveAccessTest {  
  4.     public static void main(String args[]){  
  5.         System.out.println(Cindy.language);  
  6.     }  
  7. }  


结果如下：
这里写图片描述
可见这是被动访问，Cindy自身并没有初始化

下面简要介绍装载、验证与初始化过程：
1.装载：
(1).找到该类型的class文件，产生一个该类型的class文件二进制数据流(ClassLoader需要实现的loadClassData()方法)
(2).解析该二进制数据流为方法区内的数据结构
(3).创建一个该类型的java.lang.Class实例
在加载器的相关代码中可以看到，最终通过defineClass()创建一个Java类型对象(Class对象)。
2.验证：
class文件校验器需要四趟独立的扫描来完成验证工作，其中：
第一趟扫描在装载时进行，会对class文件进行结构检查，如
(1).对魔数进行检查，以判断该文件是否是一个正常的class文件
(2).对主次版本号进行检查，以判断class文件是否与java虚拟机兼容
(3).对class文件的长度和类型进行检查，避免class文件部分缺失或被附加内容。
第二趟扫描在连接过程中进行，会对类型数据进行语义检查，主要检查各个类的二进制兼容性(主要是查看超类和子类的关系)和类本身是否符合特定的语义条件
(1).final类不能拥有子类
(2).final方法不能被重写(覆盖)
(3).子类和超类之间没有不兼容的方法声明
(4).检查常量池入口类型是否一致(如CONSTANT_Class常量池的内容是否指向一个CONSTANT_Utf8字符串常量池)
(5).检查常量池的所有特殊字符串，以确定它们是否是其所属类型的实例，以及是否符合特定的上下文无关语法、格式
第三趟扫描为字节码验证，其验证内容和实现较为复杂，主要检验字节码是否可以被java虚拟机安全地执行。
第四趟扫描在解析过程中进行，为对符号引用的验证。在动态连接过程中，通过保存在常量池的符号引用查找被引用的类、接口、字段、方法时，在把符号引用替换成直接引用时，首先需要确认查找的元素真正存在，然后需要检查访问权限、查找的元素是否是静态类成员而非实例成员。
3.准备：
为类变量分配内存、设置默认初始值(内存设置初始值，而非对类变量真正地进行初始化，即类中声明int i = 5，但实际上这里是分配内存并设置初始值为0)
4.解析：
在类的常量池中寻找类、接口、字段、方法的符号引用，将这些符号引用替换成直接引用
5.初始化：
对类变量赋予指定的初始值(这个时候int i = 5就必须赋予i以初值5)。这个初始值的给定方式有两种，一种是通过类变量的初始化语句，一种是静态初始化语句。而这些初始化语句都将被Java编译器一起放在方法中。
如前面所述，一个类的初始化需要初始化其直接超类，并递归初始化其祖先类，初始化是通过调用类的初始化方法完成的。此外，对于接口，并不需要初始化其父接口，而只需要执行该接口的接口初始化方法就可以了。
注意：
(1). 在初始化阶段，只会为类变量(静态全局变量)进行初始化工作，并且当类变量声明为final类型切初始化语句采用了常量表达式方式进行初始化赋值，那么， 也不会对其进行初始化，它将会直接被编译器计算并保存在常量池中，并且对这些变量的使用也将直接将其变量值嵌入到字节码中。
如UsefulParameter类如下：

[java] view plain copy
  1. Class UsefulParameter{   
  2. static final int height = 2;   
  3. static final int width = height * 2;   
  4. }  


类Area的类变量初始化如下：

[java] view plain copy
 
  1. Class Area{   
  2. static int height = UsefulParameter.height * 2 ;   
  3. static int width = UsefulParameter.width * 2;   
  4. }  

在Area的< clinit>中，将直接把2、4嵌入到字节码中

(2).接口的初始化与类有所不同，在初始化阶段，会为在接口中声明的所有public、static和final类型的、无法被编译为常量的字段进行初始化
6.类实例化
这里需要明白什么是类初始化，什么是类实例化，以及类的实例对象的初始化
如前面所述，类初始化时对类(静态)变量赋予指定的初始值，类初始化之后就可以访问类的静态字段和方法，而访问类的非静态(实例)字段和方法，就需要创建类的对象实例，故类的实例化是在类的初始化之后，是在堆上创建一个该类的对象。
类的静态方法和字段属于类，作为类型数据保存在方法区，其生命周期取决于类，而实例方法和字段位于Java堆，其生命周期取决于对象的生命周期。
　　类的初始化会从祖先类到子类、按出现顺序，对类变量的初始化语句、静态初始化语句块依次进行初始化。而对类实例的初始化也类似，会从祖先类到子类、按出现顺序，对类成员的初始化语句、实例初始化块、构造方法依次进行初始化。
比如：

[java] view plain copy
 
  1. package com.ice.init;  
  2.   
  3. public class Parent {  
  4.     public static int i = print("parent static:i");  
  5.     public int ii = print("parent:ii");  
  6.   
  7.     static{  
  8.         print("父类静态初始化");  
  9.     }  
  10.   
  11.     {  
  12.         print("父类实例初始化");  
  13.     }  
  14.   
  15.     public Parent(String str) {  
  16.         System.out.println("parent constructor:" + str);  
  17.     }  
  18.   
  19.     public static int print(String str){  
  20.         System.out.println("initial:" + str);  
  21.         return i;  
  22.     }  
  23. }  

子类Child如下：

[java] view plain copy
 
  1. package com.ice.init;  
  2.   
  3. public class Child extends Parent{  
  4.     public static int i = print("child static:i");  
  5.     public int ii = print("child:ii");  
  6.   
  7.     static{  
  8.         print("子类静态初始化");  
  9.     }  
  10.   
  11.     {  
  12.         print("子类实例初始化");  
  13.     }  
  14.   
  15.     public Child(String str) {  
  16.         super(str);  
  17.         System.out.println("Child constructor:" + str);  
  18.     }  
  19.   
  20.     public static int print(String str){  
  21.         System.out.println("initial:" + str);  
  22.         return i;  
  23.     }  
  24.   
  25.     public static void main(String args[]){  
  26.         Child child = new Child("cindy");  
  27.     }  
  28. }  

其初始化顺序为：


补充说明

1、执行顺序：父类的静态代码块—>子类的静态代码块—>父类的构造代码块—>父类的构造方法—>子类的构造代码块—>子类的构造方法。

2、静态代码块随类的加载而执行，只执行一次，优先于main方法，用于初始化整个类。

3、构造代码块是给一个类的所有的对象进行初始化，可执行多次。只要对象一建立，就会调用构造代码块。构造代码块可以重复，可以有多份。

4、构造方法是给与之对应的对象进行初始化，有针对性。构造方法要么带参数，要么不带参数。当类中没有显式的构造方法时，jvm会默认执行一个不带参数的构造方法。同一个类中不能出现两个或两个以上相同的构造方法（方法名和参数列表都相同）。

5、在子类的所有构造方法中如果没有显式的super语句，则默认第一条语句为隐式的super语句：super();会访问父类的不带参数的构造方法。当父类中只有带参数的构造方法时，子类必须用显式的带参数的super语句访问父类的构造方法。若显示的super语句不带参数，则编译失败。当父类中只有显式的不带参数的构造方法时，子类必须用显示的不带参数的super语句访问父类的构造方法。否则，编译失败。

6、在创建子类的实例对象时未传入参数，若子类只有带参数的构造方法则编译失败。若子类有不带参数的构造方法，则执行子类的不带参数的构造方法。若子类没有构造方法，则执行隐式的不带参数的构造方法。

7、在创建子类的实例对象时传入参数：若子类有带参数的构造方法，则执行子类的带参数的构造方法；若子类没有带参数的构造方法或者没有构造方法，则编译失败


Java编译器为每个类生成了至少一个实例初始化方法< init >，一个< init >方法分为三部分： 另一个初始化方法< init >()，对任意实例成员的初始化的字节码，构造方法的方法体的字节码
< init >方法的调用如下：
若< init >指明从this()方法明确调用另一个构造方法，那么将调用另一个构造方法，否则，若该类有直接超类，那么，若< init >指明从super()方法明确调用其超类的构造方法，那么将调用超类的构造方法，否则，将默认调用超类的无参构造方法。这样，将从其祖先类到该 类，分别完成对应的实例成员的初始化(可能被子类覆盖)
接下来以一道题结束本节：
判断输出：

[java] view plain copy
 
  1. package com.ice.init;  
  2.   
  3. class T  implements Cloneable{  
  4.       public static int k = 0;  
  5.       public static T t1 = new T("t1");  
  6.       public static T t2 = new T("t2");  
  7.       public static int i = print("i");  
  8.       public static int n = 99;  
  9.   
  10.       public int j = print("j");  
  11.       {  
  12.           print("构造块");  
  13.       }  
  14.   
  15.       static {  
  16.           print("静态块");  
  17.       }  
  18.   
  19.       public T(String str) {  
  20.           System.out.println((++k) + ":" + str + "    i=" + i + "  n=" + n);  
  21.           ++n; ++ i;  
  22.       }  
  23.   
  24.       public static int print(String str){  
  25.           System.out.println((++k) +":" + str + "   i=" + i + "   n=" + n);  
  26.           ++n;  
  27.           return ++ i;  
  28.       }  
  29.   
  30.       public static void main(String[] args){  
  31.           T t = new T("init");  
  32.       }  
  33.     }  
题解如下：
(1).首先T类被加载、连接后进行初始化，会先对字段k、t1、t2、i、n以及static块进行初始化。 (2).t1实例的初始化会初始化实例成员j，(实际上先进行父类实例内容的初始化)先调用静态方法print，并执行实例初始化块{}，输出：  1: j i=0 n= 0(i和n都还没有初始化)  2:构造块 i=1 n=1 (3)随后调用t1实例的构造函数，输出：  3:t1 i=2 n=2 (4).类似有t2实例的初始化：  4: j i=3 n= 3  5:构造块 i=4 n=4  6:t2 i=5 n=5 (5).i的初始化：  7.i i=6 n=6 (6).n的初始化和静态块的初始化：  8.静态块 i=7 n=99(n已经被初始化) (7).t实例的初始化：  9.j i=8 n= 100  10.构造块 i=9 n= 101  11.init i=10 n= 102.


看完文章后，有点疑惑，于是问了作者两个问题：

1. 最后一道题中，t1实例的初始化的时候，为何不是先执行静态代码块，而是先初始化public int j = print("j");
2. 初始化public static T t1 = new T("t1");这语句的时候，由于类T中又会包含字段k、t1、t2、i、n以及static块，如此会不会出现无限嵌套的过程


作者的回答如下：

1.t1在实例化的时候，初始化还不完全，就会使用当前的部分初始化结果完成对象的初始化，就好像父亲拿来一堆玩具，有什么孩子才能玩什么，不会孩子自己去拿玩具。你也可以试试调整静态成员顺序，观察结果
2.静态成员或类成员是类所持有的，为所有实例共享，类初始化不会有无限循环的情况。但如果不是类成员而是实例成员就会无限循环StackOverflow了，你可以自己做做实验。


阅读全文
0 0
民用枪持枪证 知乎 民用枪持枪证 知乎
原创粉丝点击
热门IT博客
网络捕鱼赢钱游戏技巧网络捕鱼赢钱游戏技巧
大数据国外研究现状大数据国外研究现状
dashboard js
新东方艾力网络课程
cs6如何删除元数据
易语言 tcp 发送数据
软件著作权怎么缴费
制作证件照软件
国产分布式数据库
sql group by 条件
oracle数据库执行脚本
淘宝扁带运动
python新手入门
淘宝羊绒哈伦九分女裤
施工进度编制软件
软件创业项目容易吗?
苹果六导入照片mac
简单的计算机编程
科比个赛季数据
优化人员结构
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 铜仁人事考试信息网 贵州铜仁景区 铜仁哪里好玩 贵州铜仁房价 铜仁星级酒店 铜仁有哪些旅游景点 贵州省铜仁第一中学 成都到贵州铜仁 铜仁做人流多少钱 铜仁网站建设 铜仁哪些地方好玩 铜仁桃源酒店 贵州铜仁学院 铜仁有什么景点 贵州铜仁景点 铜仁周边的旅游景点 铜仁有什么好吃的 铜仁花果山酒店 铜仁是哪里的 贵阳到铜仁票价 铜仁有几个县 铜报价 铜价格网 金属铜价格 电解铜价格走势图 现铜价格 今日铜价格走势图 铜现在什么价格 上海铜价格走势图 铜现货价格走势图 铜价钱 光亮铜价格 铜 价格 废铜行情走势图 铜历史价格走势图 黄铜今日价格 今日光亮铜报价 铜网价格 铜市场价 今天铜的价格 铜现价

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里