JAVA语言动手动脑问题

早期经常这样定义变量
int value=100;
前面的示例中这样定义变量
MyClass obj = new MyClass();

这两种方式定义的变量是一样的吗？

答：不一样，后者开辟了空间，而且后者的意思是，为 MyClass类的对象obj构造空间，并且调用MyClass的构造函数。

对象变量也可以使用“==”判断两变量值是否相等吗？

第一个执行结果为true，第二个执行结果为false，这代表对象变量还有字符串不可以用==判断两变量值是否相等，因为他们比较的是两个对象或者字符串的地址，如果声明了两个对象或者字符串那么他们的地址不会相等所以会是false。

但是如果有两个对象obj1=obj2，那么用==判定之后的结果为true，如果真的要判断两个字符串或者对象的值是否相等那么就要用equals()方法，并且equals()方法来自于继承，虽然在主方法中没有写继承，但是它继承的是父类Object类，而且是最大的父类，所以默认情况下不写继承。

请总结一下，这个方法有哪些“与众不同之处”，你能列出几条？

答：该方法与类名称相同，并且无返回值类型（不用void），并且如果没有声明构造方法的时候，系统会自动生成一个默认构造方法，继承于Object类，并且如果，声明了构造方法，那么再去调用默认构造方法就会报错，这也是为什么第二个图片编译过程中会报错，因为提供了构造方法，但是却调用了默认构造方法所以报错

4.执行结果如下

由此可见，1执行类成员定义时指定的默认值或类的初始化块，到底执行哪一个要看哪一个“排在前面”,2执行类的构造函数。类的初始化块不接收任何的参数，而且只要一创建类的对象，它们就会被执行。因此，适合于封装那些“对象创建时必须执行的代码”。

5.TestStaticInitializeBlock.java执行结果如下

 1 class Root
 2 {
 3     static{
 4         System.out.println("Root的静态初始化块");
 5     }
 6     {
 7         System.out.println("Root的普通初始化块");
 8     }
 9     public Root()
10     {
11         System.out.println("Root的无参数的构造器");
12     }
13 }
14 class Mid extends Root
15 {
16     static{
17         System.out.println("Mid的静态初始化块");
18     }
19     {
20         System.out.println("Mid的普通初始化块");
21     }
22     public Mid()
23     {
24         System.out.println("Mid的无参数的构造器");
25     }
26     public Mid(String msg)
27     {
28         //通过this调用同一类中重载的构造器
29         this();
30         System.out.println("Mid的带参数构造器，其参数值：" + msg);
31     }
32 }
33 class Leaf extends Mid
34 {
35     static{
36         System.out.println("Leaf的静态初始化块");
37     }
38     {
39         System.out.println("Leaf的普通初始化块");
40     }    
41     public Leaf()
42     {
43         //通过super调用父类中有一个字符串参数的构造器
44         super("Java初始化顺序演示");
45         System.out.println("执行Leaf的构造器");
46     }
47 
48 }
49 
50 public class TestStaticInitializeBlock
51 {
52     public static void main(String[] args) 
53     {
54         new Leaf();
55         
56 
57     }
58 }

结果如下

可以发现，用顺序来说，A类的子类B，B的子类C，如果执行C的构造方法，则先执行A的构造方法，在执行B的构造方法，最后执行C的构造方法。

另一方面，静态构造代码块的执行顺序最优先，然后是普通构造代码块，然后是无参构造方法，最后是有参构造方法。

另外，会先执行每个类的静态代码块，最后再按上面的顺序执行每个类的非静态代码块。

静态方法中只允许访问静态数据，那么，如何在静态方法中访问类的实例成员（即没有附加static关键字的字段或方法）?
请编写代码验证你的想法。（发表到博客）代码如下

 1 public class jingtaihanshu {
 2 int x=4;
 3 static int y=5;
 4 public static void Method (){
 5     System.out.println("实例变量x = " + new jingtaihanshu().x);//在静态方法中访问类的实例变量需首先进行类的实例化
 6     System.out.println("静态变量y = " + y);//在静态方法中可直接访问类的静态变量
 7     
 8 }
 9 public static void main(String []args){
10     jingtaihanshu.Method();
11     jingtaihanshu asd=new jingtaihanshu();
12     System.out.println("新变量的x值为："+asd.x);
13 }
14 }

结果为：

实例变量x = 4
静态变量y = 5
新变量的x值为：4

由此可知在外部调用静态方法时，可以使用"类名.方法名"的方式，也可以使用"对象名.方法名"的方式。而实例方法只有后面这种方式。也就是说，调用静态方法可以无需创建对象

7.Integer类的装箱和拆箱到底是怎样实现的？

 1 public class BoxAndUnbox {
 2 
 3     /**
 4      * @param args
 5      */
 6     public static void main(String[] args) {
 7         int value=100;
 8 
 9         Integer obj=value;  //装箱
10 
11         int result=obj*2;     //拆箱
12 
13     }
14 
15 }

每个原始数据类型的包装类分别是每个数据类型标识符的完全体首字母大写形式，例如int包装类为Integer类，其中先要定义一个变量，然后【包装类】标识符1 = 标识符2；然后拆箱原始数据类型标识符3 = 标识符2*2 ；然后反编译之后发现，装箱过程是通过调用包装器的valueOf方法实现的，而拆箱过程是通过调用包装器的 intValue方法实现的.

两对整数明明完全一样，为何一个输出true，一个输出false？

由此可见 valueOf()相会重新new一个对象，再用==比较，就是比较两个对象的地址，所以就不相等了，所以代码结果就是false。

JAVA语言动手动脑问题

猜你喜欢