标签: scjp

这是一个scjp模拟考试题.

假设我有以下两个文件:

package pkg;

public class Kit {
    public String glueIt (String a, String b) {return a+b;}
}

import pkg.*;

class UseKit {
    public static void main(String[]args) {
        String s = new Kit().glueIt(args[1],args[2]);
        System.out.println(s);
    }
}

以下目录结构:

test
   |--UseKit.class
   |
   com
     |--KitJar.jar

当前目录是test,文件pkg/Kit.class在KitJar.jar

根据答案,产生输出bc的java调用是

java -classpath com/KitJar.jar:. UseKit a b c 

请解释运营商":"和"."的使用.

来自SCJP测试的问题:

 class A{
      A aob;
      public static void main(String args[]){
           A a=new A();
           A b=new A();
           A c=new A();
           a.aob=b;
           b.aob=a;
           c.aob=a.aob;
           A d=new A().aob=new A();
           c=b;
           c.aob=null;
           System.gc();
      } 
  }

问题:c.aob=null执行后,有多少对象符合垃圾回收的条件.

我认为1,但正确答案2.出了什么问题？

在得到正确答案之后,我无法弄清楚SCJP的问题:

从以下代码(来源:http://scjptest.com),我们需要确定何时被引用为myInt的对象有资格进行垃圾回收:

01.public void doStuff() {  
02.    Integer arr[] = new Integer[5];  
03.    for (int i = 0; i < arr.length; i++) {  
04.        Integer myInt = new Integer(i);  
05.        arr[i] = myInt;  
06.    }  
07.    System.out.println("end");  
08.}

答案表明它符合第6行的GC条件.但我认为直到第7行之后,该对象根本不能用于GC.因为,被引用为myInt的对象也被称为arr [i].所以,你不觉得,因为,在myInt超出范围之后,arr []仍然会引用它直到第8行？

这个问题就像是我以前的一个 假设:

3. interface Animal { void makeNoise(); }
4. class Horse implements Animal {
5.   Long weight = 1200L;
6.   public void makeNoise() { System.out.println("whinny"); }
7.  }
8.  public class Icelandic extends Horse {
9.   public void makeNoise() { System.out.println("vinny"); }
10.  public static void main(String[] args) {
11.    Icelandic i1 = new Icelandic();
12.    Icelandic i2 = new Icelandic();
13.    Icelandic i3 = new Icelandic();
14.    i3 = i1; i1 = i2; i2 = null; i3 …

K.Sierra在她的书"SCJP学习指南"中提到"我们知道一个文字整数总是一个整数,但更重要的是,一个涉及任何大小或更小的表达式的结果总是一个整数."

我已经开始尝试了,我对以下结果有点困惑:

byte a = 1; // correct
byte b = 1 + a; // incorrect (needs explicit casting)
byte c = 1 + 1; // correct (I expected it to be incorrect)

任何人都可以向我解释为什么最后一个例子不需要投射？为什么Java编译器会进行隐式转换？是因为有2个文字吗？澄清非常感谢.

在我为 OCJP 学习时，我遇到了以下问题：

class CardBoard {
           Short story = 200;
           CardBoard go(CardBoard cb) {
                cb = null;
                return cb;
           }
           public static void main(String[] args) {
             CardBoard c1 = new CardBoard();
             CardBoard c2 = new CardBoard();
             CardBoard c3 = c1.go(c2);
             c1 = null;
            // do Stuff 
}}

当达到 //doStuff 时，有多少对象符合 GC 条件？
正确答案是2，意思c1和story对象。

当到达行 //doStuff 时，c3 也为空。为什么它也没有资格进行 GC？

这是来自OCJP 6考试的问题,因此故意不完全正确(但合法).

给定代码:

class ToDos {
    String day;

    public ToDos(String d) {
        day = d;
    }

    public boolean equals(Object o) {
        return ((ToDos) o).day == day;
    }

    public int hashCode() { return 9; }
}

public class MapEQ {

    public static void main(String[] args) {
        Map<ToDos, String> map = new HashMap<ToDos, String>();

        ToDos t1 = new ToDos("Monday");
        ToDos t2 = new ToDos("Mond" + "a" + "y");
        ToDos t3 = new ToDos("Tuesday");

        map.put(t1, "a");
        map.put(t2, "b");
        map.put(t3, "c");

        System.out.println(map.size());
    }

} …

晚上好,请查看此代码示例,其中显示了符合GC条件的对象数量:

public class CardBoard {

Short story = 5;

CardBoard go(CardBoard cb) {
    cb = null;
    return cb;
}

public static void main(String[] args) {
    CardBoard c1 = new CardBoard();
    CardBoard c2 = new CardBoard();
    CardBoard c3 = c1.go(c2);
    c1 = null;
   // do Stuff

   }
}

我看到有四个对象符合GC的条件,当达到了东西时,它是c3,它是关联的故事对象和c1以及它的相关故事对象,你看到了什么？

当我练习参加OCJP考试时,我发现我想要练习的问题通常都是技巧问题,试图欺骗我回答错误.这个例子来自Bathes/Sierra的书,一个典型的技巧问题是:

现在我想知道你是否可以告诉我,真实考试中的问题是否经常是这样的技巧问题,或者实际考试是否有另一种风格,或者这是否接近我的期望？

来自Niko的java博客

这些类在同一文件中定义.什么是输出？(1个正确答案)

class Job extends Thread {
    private Integer number = 0;
    public void run() {
        for (int i = 1; i < 1000000; i++) {
            number++;
        }
    }
    public Integer getNumber() {
        return number;
    }
}
public class Test {
    public static void main(String[] args) 
    throws InterruptedException {
        Job thread = new Job();
        thread.start();
        synchronized (thread) {
            thread.wait();
        }
        System.out.println(thread.getNumber());
    }
}

• 它打印0.
• 它打印999999.
• 输出不保证是上述任何一种.

输出是999999.我理解当一个Thread完成它的run()方法时,它会终止并随之释放Thread释放的所有锁.但是,在本练习中,它使用Thread对象作为锁,不应该将它视为普通对象吗？我的意思是锁不是由Thread拥有的,thread而是由主线程拥有的.