标签: scjp

class Another {
    public void method(Object o) {
        System.out.println("This is in method which takes object");
    }
    public void method(String s) {
        System.out.println("This is method which takes string");
    }
}

public class NewClass {
    public static void main(String args[]) {
        Another an = new Another();
        an.method(null);
    }
}

当我尝试执行此操作时,我明白了

这是采用字符串的方法

作为输出.为什么不"这是采取对象的方法"？对象也可以为null,string也可以为null,为什么不调用第一个方法？

我知道我们不能在java中的if语句中使用赋值运算符,因为我们在其他几种语言中使用它.

那是

            int a;

            if(a = 1) {  } 

会给出编译错误.

但是下面的代码工作得很好,怎么样？

           boolean b;

           if(b = true) {   }

编辑:这是一个例外,规则不能在if语句中使用赋值.

我一直在SCJP学习指南中阅读有关Statics的部分,它提到了以下内容:

静态方法不能被覆盖,但可以重新定义它们

重新定义实际意味着什么？是否存在父和子都存在的静态方法,具有相同的签名,但是它们的类名分别引用它们？如 :

class Parent
{
   static void doSomething(String s){};
}

class Child extends Parent
{
   static void doSomething(String s){};
}

引用为:Parent.doSomething();和Child.doSomething();？

此外,这同样适用于静态变量,还是静态方法？

我正在为SCJP做准备(最近由甲骨文重新命名为OCPJP),我在模拟考试中遇到的一个特殊问题让我感到困惑,答案描述并没有解释清楚的事情.

这是个问题:

class A 
{
    int x = 5;
} 
class B extends A 
{
    int x = 6;
} 
public class CovariantTest 
{
    public A getObject() 
    {
       return new A();
    } 
    public static void main(String[]args) 
    {
       CovariantTest c1 = new SubCovariantTest();
       System.out.println(c1.getObject().x);
    }
}

class SubCovariantTest extends CovariantTest 
{
    public B getObject() 
    {
       return new B();
    }
}

答案是5,但我选择了6.

我知道覆盖适用于运行时的方法,而不是变量,但我的思维解释方式println是:

1. 在c1上调用getObject
2. c1实际上是一个SubCovariantTest对象,并且具有有效覆盖getObject(),因此请使用重写方法
3. 覆盖返回B,因此从B抓取x,即6

是JVM忽略该getObject()部分的情况,并且总是x从c1 …

在以下代码示例中:

class Parent { 
    int x =5;
    public Integer aMethod(){

        System.out.print("Parent.aMthod ");
        return x;
    }
}

class Child extends Parent {
    int x =6;
    public Integer aMethod(){
        System.out.print("Child.aMthod "); 
        return x;
    }
}


class ZiggyTest2{

    public static void main(String[] args){

        Parent p = new Child();
        Child c = new Child();

        System.out.println(p.x + " " + c.x);

        System.out.println(p.aMethod() + "  \n");
        System.out.println(c.aMethod() + "  \n");
    }   
}

并输出:

5 6
Child.aMthod 6  

Child.aMthod 6

p.aMethod()当px打印6时,为什么不打印6？

谢谢

编辑

哎呀一个小错字:问题应该是"为什么p.aMethod()在px print 5时不打印5" …

上下文:

似乎太阳认证的简单scjp - > scja - > .... track已经与其他oracle风格认证合并......作为开发人员,我最近花了一些时间试图找出新的"路径"用于认证.

现有资源:

这里有一个非常密集但信息丰富的页面:http://en.wikipedia.org/wiki/Sun_Certified_Professional Oracle网站当然也充满了具有不同认证事实的链接和图表.

我的问题:

目前尚不清楚是否有新的范例或新认证途径正在出现,因此旧的SCJP风格认证是否仍然存在(尽管标题不同),也不清楚整个认证管道是什么样的:例如,这个图表(来自较旧的太阳认证)http://www.whizlabs.com/images/jwhiz.png,清楚地将无数的认证和培训计划与清晰且易于理解的图表相关联.但我没有看到任何这样的资源来解释和比较现代Oracle Java认证.

问题:

新的Oracle认证之间有什么关系？它们与最初的SCJP,SCJD和SCEA考试有什么关系？

我正在研究SCJP考试,在做了一些模拟测试后,我遇到了这个:

它询问以下输出是什么:

class TestClass
{
   int i = getInt();
   int k = 20;
   public int getInt() {  return k+1;  }
   public static void main(String[] args)
   {
      TestClass t = new TestClass();
      System.out.println(t.i+"  "+t.k);
   }
}

我以为会是这样21 20,因为ti会调用getInt,然后将k增加到21.

但答案是1 20.我不明白为什么会这样,有人可以对此有所了解吗？

在下面的代码片段中,将doThings()方法声明为static将使类成为线程安全的.原因是如果启动了多个TestSeven线程,并且由于x是静态变量,可能会出现竞争条件？

public class TestSeven extends Thread{

    private static int x;

    public synchronized void doThings(){
        int current = x;
        current++;
        x = current;
    }

    public void run(){
        doThings();
    }

    public static void main(String args[]){
        TestSeven t = new TestSeven();
        Thread thread = new Thread(t);
        thread.start();
    }
}

在使用类加载器时,我遇到以下异常:

Exception in thread "main" java.lang.ClassCastException: xxx.Singleton cannot be cast to xxx.Singleton

这是否意味着类加载器中的实例不能转换为另一个类加载器的类？

检查我的代码,我可以通过类加载器实现3个单例,即使是""安全性.

public static void main(String[] args) throws Exception {
        URL basePath = new URL("file:/myMavenPath/target/classes/");

    Object instance = getClassInstance(Singleton.class);
    System.out.println(instance);
    //
    Object instance2 = getClassInstance(
            new URLClassLoader( new URL[]{basePath} , null )
                    .loadClass("my.Singleton")
    );
    System.out.println(instance2);
    //
    Object instance3 = getClassInstance(
            new URLClassLoader( new URL[]{basePath} , null )
                    .loadClass("my.Singleton")
    );
    System.out.println(instance3);

    // Only the 1st cast is ok
    Singleton testCast1 = (Singleton) instance;
    System.out.println("1st cast ok");
    Singleton testCast2 = …

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

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

和

StringBuffer aStringBufferObject = new StringBuffer("A");

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

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

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

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