SCJP_104——题目分析（4）

14. which three are valid declaraction of a float? ADF
A. float foo=-1;
B. float foo=1.0;
C. float foo=42e1;
D. float foo=2.02f;
E. float foo=3.03d;
F. float foo=0x0123;

这一题考的是 Java 的基本数据类型和类型转换。

在 Java 中规定，整数字面值默认为 int 类型，浮点数字面值默认为 double 类型。

A：-1 是 int 类型，可以自动转换成 float 类型。

B：1.0 是 double 类型，高位向低位转换，会丢失精度，Java 不允许这样的转换，除非进行强制转换。

C：42e1 是 double 了性，理由同上。

D：答案正确。

E：3.03d 是 double 类型。

F：0X0123 是整数291，会自动进行类型转换。

所以答案是：ADF

---

16.
1) public class Test{
2) public static void main(String args[]){
3) int i=0xFFFFFFF1;
4) int j=~i;
5)
6) }
7) }

which is decimal value of j at line 5? 
A. 0 B.1 C.14 D.-15 E. compile error at line 3

这里考察的是 Java 中的进制转换和位运算符

0xFFFFFFF1 是十六进制，转换成 2 进制是 1111 1111 1111 0001

同时 ~ 是取补码的运算，也就是 0 变 1，1 变 0，运算后的结果是 0000 0000 0000 1110，转换成 10 进制是 14。

所以正确答案是：C

---

17.
float f=4.2F;
Float g=new Float(4.2F);
Double d=new Double(4.2);
Which are true?
A. f==g     B. g==g      C. d==f      D. d.equals(f)     E d.equals(g)     F. g.equals(4.2);

这里考察了 Java 中的对象引用、==、equals 的知识点

f 表示 float 变量的名字，g 表示对象的引用，所以 f == g ，这样的比较是不合法的

g 是一个指向 Double 的引用，g == g，g 肯定是等于 g，所以正确。

d == f 和 f == g 类似，也是不合法的

equals，这里要注意，要和 == 区分开来，重点说明一下 == 和 equals 之间的区别。

首先要说 Java 中的数据类型。在 Java 中有两种数据类型：基本数据类型和引用数据类型。

基本数据类型包括：

　　byte、short、int、char、long、float、double、boolean

它们之间的比较应该用 == 进行比较，比较的是它们的值。

除了这 8 中基本数据类型以外的数据类型，都叫引用数据类型。所谓引用，就是内存中的地址。因为在 Java 中，为了安全，用一个类似指针的东西来指向存放数据的内存地址。所以对引用数据类型来说，当使用 == 进行比较的时候，比较的是内存中的地址。

所以，除非两个引用变量指向同一个内存地址，使用 == 进行比较才能得到 true，否则就是 false

Java 当中所有的类都是继承于Object这个基类的，在Object中的基类中定义了一个equals的方法，这个方法的初始行为是比较对象的内存地 址，但在一些类库当中这个方法被覆盖掉了，如String,Integer,Date在这些类当中equals有其自身的实现，而不再是比较类在堆内存中的存放地址了。

下面说几个例子，看看 equals 和 ==  区别

例子1：

public class TestString
{
    public static void main(String[] args)
    {
        String s1 = "Monday";
        String s2 = "Monday";

        if (s1 == s2)
            System.out.println("s1 == s2");
        else
            System.out.println("s1 != s2");
    }
}

输出结果：

s1 == s2

在稍微改动下程序

例子2：

public class Test
{
    public static void main(String args[])
    {
        String s3 = "Monday";
        String s4 = new String("Monday");

        if (s3 == s4)
        {
            System.out.println("s3 == s4");
        }
        else
        {
            System.out.println("s3 != s4");
        }

        if (s3.equals(s4))
            System.out.println("s3 equals s4");
        else
            System.out.println("s3 not equals s4");
    }
}

输出结果

s3 != s4
s3 equals s4

结果为什么会是这样？

这里涉及到了一个字符串缓存池的概念。

原来，程序在运行的时候，会创建一个字符串缓存池。当使用 String s2 = "Monday" 创建一个字符串的时候，程序首先会在字符串缓冲池中寻找相同值的对象。而之前已经创建了一个 s1 对象，所以在 s2 被创建的时候，程序找到了具有相同值的 s1。这样一来，s1 和 s2 就有了相同的地址。所以就有了例子 1 中的输出结果。

在例子 2 中，s4 使用了关键字 new，在内存开辟了一个空间用来存放 "Monday"，s4 指向这个内存位置。所以结果就很明显了。

参考资料：http://www.cnblogs.com/jackyrong/archive/2006/08/20/481994.html

感谢参考资料作者的辛勤劳动