Simple, common interests, code-based parsers, Java questions

Here are my answers to some of your questions:

Question number 2 :

I think you are using properties incorrectly. These methods should be named getPBar and setPBar.

String pBar;

void setPBar(String str) {...}
String getPBar() { return pBar};

      

        
        
        
      

    

The JavaBeans specification states that:

For readable properties, a getter method will be available to read the property value. The writable properties will have a setter method that will update the property value. [...] Creates a PropertyDescriptor for a property following standard Java convention using the getFoo and setFoo methods. Thus, if the argument name is "fred", the read method is assumed to be "getFred" and the write method is "setFred". Note that the property name must begin with a lowercase character, which will be capitalized in method names.

Question number 3 :

I agree with the offer of the software you are using. For readability, only one exit point is better. For efficiency use 'return;' could be better. I assume the compiler is smart enough to always choose an efficient alternative, and I bet the bytecode is the same in both cases.

FURTHER EMPIRICAL INFORMATION

I did some tests and found out that the java compiler I am using (javac 1.5.0_19 on Mac OS X 10.4) does not apply the expected optimizations.

I've tested the following class:

public abstract class Test{

  public int singleReturn(){   
     int ret = 0;
     if (cond1())
         ret = 1;
     else if (cond2())
         ret = 2;
     else if (cond3())
         ret = 3;

    return ret;
  }

  public int multReturn(){
    if (cond1()) return 1;
    else if (cond2()) return 2;
    else if (cond3()) return 3;
    else return 0;
  }

  protected abstract boolean cond1();
  protected abstract boolean cond2();
  protected abstract boolean cond3();
}

      

        
        
        
      

    

Then I analyzed the bytecode and found that there are multiple rotation operators for multReturn (), and there is only one for singleReturn (). Moreover, the singleReturn () bytecode also includes several gotos in the return statement.

I have tested both methods with very simple cond1, cond2 and cond3 implementations. I have verified that there are three conditions that are equally provable. I found a consistent time difference of 3% to 6% in favor of multReturn () . In this case, since the operations are very simple, the impact of multiple returns is quite noticeable.

I then tested both methods using a more complex implementation of cond1, cond2, and cond3 to make the impact of different returns less obvious. I was shocked by the result! Now multReturn () is consistently slower than singleReturn () (2% to 3%). I don't know what is causing this difference, because the rest of the code should be the same.

I think these unexpected results are caused by the JVM JIT compiler.

Anyway, I agree with my initial intuition: the compiler (or JIT) can optimize things like this, and this frees up the developer to focus on writing code that is easy to read and maintain.

Question number 6 :

You can call a class method from your instance method and leave that static method by changing the class variable.

Then your code looks something like this:

public static void clearInstance() {
    instance = null;
}

@Override
public void handleEvent(Event e) {
    switch (e.type) {
        case SWT.Dispose: {
            if (e.widget == getComposite()) {
                MyClass.clearInstance();
            }
       break;
         }
    }
}

      

        
        
        
      

    

This will lead to the warning you described in 5, but there must be some compromise, in which case it is just a smell and not a bug.

Question number 7 :

It's just the smell of a potential problem. This is not necessarily bad or wrong, and you cannot be sure just using this tool.

If you have a real problem like constructor dependencies, testing should show that.

Another but related issue is circular dependencies between jars: while classes with circular dependencies can be compiled, circular dependencies between jars cannot be handled in the JVM because of the way class loaders work.