标签: scjp

我正在攻读SCJP考试,我遇到了一个我无法真正解决的问题.

这本书说你不能加宽然后盒子,但你可以装盒然后加宽.无法框的示例是期望Long的方法,并且使用字节调用该方法.

他们的解释是:

想一想......如果它先尝试先打包,那么该字节就会被转换为字节.现在我们又回到尝试将字节扩展到Long,当然,IS-A测试失败了.

但这听起来像盒子然后加宽而不是加宽然后盒子给我.

任何人都可以澄清整个盒子并扩大与扩大和盒子对我来说因为它本来就不是很清楚这个问题.

编辑:澄清:我正在谈论SCJP sun认证程序员的第6页和第253页,用于java 6书. http://books.google.be/books?id=Eh5NcvegzMkC&pg=PA252#v=onepage&q&f=false

在http://leepoint.net/notes-java/data/expressions/precedence.html的一个例子中

以下表达式

1 + 2 - 3 * 4 / 5

被评估为

1 + 2 - 3 * 4 / 5
    = (1 + 2) - ((3 * 4) / 5)
    = 3 - (12/5)
    = 3 - 2 The result of the integer division, 12/5, is 2 .
    = 1

然后我从http://www.roseindia.net/java/master-java/operator-precedence.shtml中看到了另一个例子

以下表达式

4 + 5 * 6 / 3

被评估为

4 + (5 * (6 / 3))

我有点困惑的是如何确定哪些将在*和/涉及时首先进行评估.在上面的例子中,两者似乎都不同.

第一个例子是评估3*5/5,((3*4)/5) 而第二个例子是评估5*6/3 as …

为了准备SCJP(或现在已知的OCPJP)考试,我被一些关于传递(参考)价值和不变性的模拟问题所困扰.

我的理解是,当您将变量传递给方法时,您传递的是表示如何获取该变量的位的副本,而不是实际的对象本身.

您发送的副本指向同一个对象,因此您可以修改该对象(如果它是可变的),例如附加到StringBuilder.但是,如果对不可变对象执行某些操作(例如递增整数),则本地引用变量现在指向新对象,并且原始引用变量仍然无视此对象.

考虑我的例子:

public class PassByValueExperiment
{

    public static void main(String[] args)
    {
        StringBuilder sb = new StringBuilder();
        sb.append("hello");
        doSomething(sb);
        System.out.println(sb);


        Integer i = 0;
        System.out.println("i before method call : " + i);
        doSomethingAgain(i);
        System.out.println("i after method call: " + i);
    }

    private static void doSomethingAgain(Integer localI)
    {
        // Integer is immutable, so by incrementing it, localI refers to newly created object, not the existing one
        localI++;
    }

    private static void doSomething(StringBuilder localSb)
    {
        // localSb is a different …

鉴于此示例代码:

Runnable r = new Runnable() {
  public void run() {
    System.out.print("Cat");
  }
};
Thread t = new Thread(r) {
  public void run() {
    System.out.print("Dog");
  }
};
t.start();

为什么输出狗而不是猫？

我正在为我的OCA准备解决一些问题.我在Oracle的网站上发现了这个问题,列出了考试的示例问题.

码:

public class MyStuff {
    MyStuff(String n) { name = n; }
    String name;
    public static void main(String[] args) {
        MyStuff m1 = new MyStuff("guitar");
        MyStuff m2 = new MyStuff("tv");
        System.out.println(m2.equals(m1));
    }
    public boolean equals(Object o) {
        MyStuff m = (MyStuff)o;
        if(m.name != null) return true;
        return false;
    }
}

题:

结果是什么？

1. 输出为"true",MyStuff满足Object.equals()契约.
2. 输出为"false",MyStuff履行Object.equals()契约.
3. 输出为"true",MyStuff不符合Object.equals()契约.
4. 输出为"false",MyStuff不符合Object.equals()契约.
5. 编译失败.
6. 运行时抛出异常.

答案是 -

3. The output is "true" and MyStuff does NOT fulfill the Object.equals() contract.

我理解输出是true什么,以及为什么输出,但我没有得到的是,它怎么没有满足Object.equals()合同,以及Java中的"契约"究竟是什么,如果我们不遵守它会怎么样？

有人可以解释一下,为什么我在Java中为表示整数的四种基本类型中的两种获得不同的行为？AFAIK全部四个都是签名的,它们都使用最重要的位作为符号位,那么为什么字节和短行为正常,而int和long行为,好吧,奇怪？oracle文档的片段解释这将是完美的.

byte a = (byte) (Math.pow(2, 7)-1); //127 - as expected
short b = (short) (Math.pow(2, 15)-1); //32767 - as expected
int c = (int) (Math.pow(2, 31)-1); //2147483647 - as expected
long d = (long) (Math.pow(2, 63)-1); //9223372036854775807 - as expected

a = (byte) (Math.pow(2, 7)); //-128 - as expected
b = (short) (Math.pow(2, 15)); //-32768 - as expected
c = (int) (Math.pow(2, 31)); //2147483647 - why not '-2147483648'?
d = (long) (Math.pow(2, 63)); //9223372036854775807 - why not '-9223372036854775808'?

a …

public class AutoBoxingAndUnBoxing 
{
    public static void main(String[] args) 
    {
        Integer x = 127;
        Integer y = 127;
        System.out.println(x == y);//true

        Integer a = 128;
        Integer b = 128;
        System.out.println(a == b);//false
        System.out.println(a); // prints 128
    }
}

怎么回事x==y是真的,a==b是假的？如果它是基于值(Integer -128 To 127)那么'a'应该打印-128正确吗？

选择三个正确的答案（有效的声明）。

（一种） char a = '\u0061';

（b） char 'a' = 'a';

（C） char \u0061 = 'a';

（d） ch\u0061r a = 'a';

（e） ch'a'r a = 'a';

答案：（a），（c）和（d）

书：

Java SCJP认证程序员指南（第三版）

有人可以解释一下选项（c）和（d）的原因吗，因为IDE（IntelliJ IDEA）用红色的文字显示了它：

无法解析符号“ u0063”

假设一个线程A正在运行.我有另一个线索B,谁不是.B已经启动,处于可运行状态.

如果我打电话B.join()会怎么样？

是暂停执行A还是等待A的run()方法完成？

从OCP Java SE 6程序员实践考试的第280页开始,问题9:

int x = 3;
x = x++;
// x is still 3

在解释中我们可以读到:

该x = x++;行不会离开,x == 4因为在分配发生后++应用 了该行.

我同意这x是3,我理解增加后.

我不同意这个解释.我会用"之前"替换"之后".

我认为它的工作方式如下:

1. x 是3.

2. x++被执行.我将此增量后运算符视为函数:

   int operator++() {
       int temp = getX();
       setX(temp + 1);
       return temp;
   }
   

   Run Code Online (Sandbox Code Playgroud)

   因此,x++执行后,x是4,但从x++表达式返回的值是3.

3. 现在,分配=.简单地写返回3到x.

因此,在我的眼中,在分配发生之前++应用.我错了吗？