标签: scjp

有人可以在对象锁定的上下文中解释这两个例子之间的区别:

public void method1(){
    synchronized(this){
        ....
    }
}

和

StringBuffer aStringBufferObject = new StringBuffer("A");

public void method2(){
    synchronized(aStringBufferObject){
        ....
    }
}

我知道第一个示例将获取this实例上的锁,第二个示例将获取aStringBufferObject实例的锁.但我真的不明白两者的影响或区别.

例如,在第二个示例中,线程是否仍然能够执行synchronized块内的代码,因为锁与'this'实例无关？

我知道同步一个方法或一个代码块会阻止多个线程同时访问该块/方法,但指定要锁定的对象的目的是什么,以及指定对象的方式有何不同上面的例子？

您可能知道,有些人使用Enum of 1实例声明单例,因为JVM保证总是会有一个没有并发问题的实例来处理...

那么具有多个实例的枚举呢？我们可以说像Enum这样的东西是一种有序的单身人士共享一个共同的界面吗？为什么？

public enum EnumPriceType {

    WITH_TAXES {
        @Override
        public float getPrice(float input) {
            return input*1.20f;
        }
        public String getFormattedPrice(float input) {
            return input*1.20f + " €";
        }
        },

    WITHOUT_TAXES {
        @Override
        public float getPrice(float input) {
            return input;
        }
    },
    ;

    public abstract float getPrice(float input);

    public static void main(String[] args) {
        WITH_TAXES.getFormattedPrice(33f);
    }

}

在此代码中,为什么这不起作用:WITH_TAXES.getFormattedPrice(33f); 如果不通过公共接口无法调用公共方法,那么声明公共方法的兴趣是什么？我想这就是为什么我没有看到任何语法能够为Enum的一个实例声明一个接口.

编辑:

似乎枚举实例是一种特殊的匿名类.因此,我理解为什么你不能称之为该方法.

我的问题有点与:为什么匿名类不能实现一个接口(除了它可能已经实现的接口!)

我完全理解为什么我们不能这样做:

Vehicle veh = new Vehicle() {
    public String getName() {
        return "toto";
    }
}; …

当我运行以下示例时,我得到输出0,2,1

class ZiggyTest2{

        static int f1(int i) {  
            System.out.print(i + ",");  
            return 0;  
        } 

        public static void main(String[] args) {  
            int i = 0;  
            int j = 0;  
            j = i++;   //After this statement j=0 i=1
            j = j + f1(j);  //After this statement j=0 i=1
            i = i++ + f1(i);  //i++ means i is now 2. The call f1(2) prints 2 but returns 0 so i=2 and j=0
            System.out.println(i);  //prints 2?
        } 
    } 

我不明白为什么输出是0,2,1而不是0,2,2

为什么以下程序会抛出异常？

public class MainClass{
  public static void main(String[] argv){
       callMethod(2);
  }
  public static void callMethod(Integer... i){
       System.out.println("Wrapper");
  }
  public static void callMethod(int... i){
       System.out.println("Primitive");
  }

}

对于类型MainClass,方法callMethod(Integer [])是不明确的

好的,我可以看到两种方法中的任何一种都可以工作(如果另一种方法被注释掉),但我也知道如果一个原语与方法输入的类型不完全匹配,会发生什么情况.

尝试的第一件事是扩大原语.那么,如果有第三种方法:

      public static void callMethod(long i){
       System.out.println("long");
      }

代码会打印很长时间

第二件事是封装原语.因此,如果有一个方法采用整数,那将是一个被调用的方法.

第三个优先事项是var-args.

基于上述优先顺序,我认为第二种情况就是如此.我希望将int包装成一个Integer并调用(Integer ...).但当然这不会发生.相反,抛出异常.

是否有人看到并可以解释为什么优先级不适用于此示例？

干杯!

创建了多少个String对象

我正在为SCJP学习,我似乎无法理解这个String问题.我似乎看到几个可能的答案取决于我如何看待问题.

在以下初始化中,创建了多少个字符串对象？

String s1 = "A" + "B" + "C" + "D";
System.out.println(s1)

最初我认为5个对象,即

"A"
"B"
"C"
"D"
"ABCD"

但是后来考虑一下我不太确定,因为例如编译器会连接"A" + "B"成一个对象吗？即创建7个对象？

"A"
"B"
"C"
"D"
"AB"
"ABC"
"ABCD" 

此外,如果代码更改为,将创建多少个对象

String s1 = new String("A" + "B" + "C" + "D");
System.out.println(s1);

最后怎么样:

String s1 = "A";
String s2 = new String("A");

在上面的例子中,我认为只会创建2个对象

object 1 - "A"
object 2 - a String object that refers to the "A" object above.

这是正确的还是不相关？即,从常量池引用的对象将不同于s2引用所引用的对象.

谢谢

编辑

此外,请注意我有兴趣知道创建的对象总数,包括那些被丢弃的对象,而不仅仅是那些最终在常量池中结束的对象.

编辑

看看Jon的回答,我可能完全误解了对象的创建方式.我知道String只在常量池中创建一次并且它被重用但是我不确定在构造'final'字符串时经历的过程.以下是我正在阅读的书中的部分,它似乎表明临时对象的创建与此处的答案完全相反.(或者这本书错了或我误解了这本书)

代码示例是 …

我在书中读到OCJP for Java6这一部分有断言.我到达了一个部分,它概述了如果将'assert'一词用作关键字或标识符,编译器将如何反应.

a Keyword和an有identifier什么区别？任何人都可以给我一个简单的解释,另外还有一个或多个例子吗？

int primitivI[] = {1,1,1};
Integer wrapperI[] = {2,22,2};


1. System.out.println(primitivI instanceof Object);//true
2. System.out.println(primitivI instanceof Object[]);//Compilation Error Why ????
3. System.out.println(wrapperI  instanceof Object);//true
4. System.out.println(wrapperI  instanceof Object[]);//true

这里我有两个整数(primitve,Wrapper)类型的数组,但我对instanceof运算符有不同的结果

看到第2行和第4行第4行将成功编译并给出结果为true但是在第2行的情况下,为什么会导致编译错误？从第1行和第3行可以清楚地看出,这两个数组是对象的实例,但如果是Object[],为什么结果会有所不同？

我一直在尝试模拟ocjp 6测试.我问了一个问题,问问构造函数是否正确:

 1- public Test8(){}
 2- private void Test8(){}
 3- protected Test8(int k){}
 4- Test8(){}

正确答案是1和3.我不明白为什么4是不正确的.当我测试以下代码时:

public class Test8 {
    Test8() {}

    public Test8() {}

}

我有编译错误,但当我删除其中一个构造函数,如果编译没有任何问题.

有人可以帮我清理一下.

我认为我对Java泛型有一些很好的理解.

这段代码没有编译,我知道为什么.

我们只能传递给测试方法类型Animal的类型或它的超类型(如对象列表)

package scjp.examples.generics.wildcards;

import java.util.ArrayList;
import java.util.List;

class Animal {}
class Mammal extends Animal {}
class Dog extends Mammal {}

public class Test {

    public void test(List<? super Animal> col) {
        col.add(new Animal());
        col.add(new Mammal());
        col.add(new Dog());
    }

    public static void main(String[] args) {
        List<Animal> animalList = new ArrayList<Animal>();
        List<Mammal> mammalList = new ArrayList<Mammal>();
        List<Dog> dogList = new ArrayList<Dog>();

        new Test().test(animalList);
        new Test().test(mammalList); // Error: The method test(List<? super Animal>) in the type Test is not …

这个问题来自Kathy Sierra SCJP 1.6.有多少个对象符合垃圾收集的条件？

根据Kathy Sierra的回答,确实如此C.这意味着两个对象有资格进行垃圾回收.我给出了答案的解释.但为什么c3不符合垃圾收集(GC)的条件？

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
} }

何时// Do stuff到达,有多少对象符合GC条件？

• 答:0
• B:1
• C:2
• D:编译失败
• E:不可能知道
• F:运行时抛出异常

回答:

• C是对的.只有一个CardBoard对象(c1)符合条件,但它具有相关的Short包装器对象,该对象也符合条件.
• 基于以上原因,A,B,D,E和F不正确.(目标7.4)