Huh? There is no more need to create an object to call a static method
than there is to access a static field. If Worker could have accessed
MyClass.rootDir, it could call MyClass.getRootDir().

Whether the root directory attribute should be a static attribute of the
MyClass class is arguable, but is orthogonal to the question of whether
it should be accessed as a variable or through an access method.

Patricia

www wrote On 05/04/07 16:06,:

   In the class as you wrote it, the only way MyClass
discovers where rootDir is supposed to be is by having
somebody, somewhere, create a MyClass object and pass
the value in as an argument to the constructor.  If you
never construct a MyClass, nobody ever tells a constructor
what rootDir should be.  What should MyClass do?  Just
make something up out of thin air?

   I'm not 100% sure what you're trying to do, but if
the idea is for MyClass to "remember" the first rootDir
from the construction of the first MyClass instance,
then you can't use a static final.  Why?  Because the
static field belongs to the class and not to the instance,
and must be initialized when the class is loaded and not
later on when instances are (or aren't) constructed.

   What you might want to do instead is use a private
static variable and an accessor method, something like:

    public class MyClass {

       private static String rootDir;

       public MyClass(String dir) {
           if (rootDir == null) {
               // first instance: initialize
               rootDir = dir;
           }
       }

       public string getRootDir() {
           if (rootDir == null) {
               // optional: could just return null
               throw new IllegalStateException(...);
           }
           return rootDir;
       }
    }

There are several ways to get your variable to other classes, such as
pass them in arguments or use a singleton.  In the end it is probably
going to be easiest to have a static variable that is visible to your
other classes.  People are going to shudder though so just don't tell
them that you are doing that.

I think I see what you are trying to say.  If I understand, you don't
like the fact that there is some dependency that the worker thread knows
about the MyClass class.  I think one way to fix this is to use what is
sometimes called a Strategy Pattern or Dependency Injection.  Rather
than have Worker know about MyClass, you inject the information into
Worker, thus breaking the dependency.

In plain English, I think Worker needs to know about the context in
which it's running, so let's call this dependency a "context"

public class Worker {
    private Context localCntxt;

    public Worker( Context c ) {
        localCntxt = c;
    }
    public void doStuff() {
    //...
    String rootDir = localCntxt.getRootDir();
    //...
    }
}

Now just make MyClass a type of Context object:

public class Context {    // used to be type MyClass
    private String rootDir;
    public void setRootDir( String s ) {
        rootDir = s;
    }
    public String getRootDir() {
        return rootDir;
    }
}

Feel free to stuff Context full of every sort of variable that your
classes might ever need.

Now you can easily make lots of workers all running in the same context,
or even different contexts.

public class Main {
    public void main( String [] args ) {
        Context a = new Context();
        Context b = new Context();
        Context c = new Context();

        a.setRootDir( "/" );
        b.setRootDir( "/Users/Mark/pub" );
        c.setRootDir( "/argle/bargle/blet/foo/bar" );

        Worker w1 = new Worker( a );    // Three workers all
        Worker w2 = new Worker( a );    // running in the same
        Worker w3 = new Worker( a );    // Context
        Worker w4 = new Worker( b );    // A Different Context b
        Worker w5 = new Worker( c );    // And Context c
    }
}

I hope this made some sense to you.

It compiles with the missing semicolon added.

Arne

Yup, javap -c should show identical byte code.

Nooooo!!1! "static initialiser" (although technically initialiser should
be missplled)

Some people prefer defining a function to do that. I prefer the static
initialiser. Note, you can't qualify with the class in the assignment
("FinalDemo.s1 = "A";"). However, never use that as an excuse to miss
the final!

Tom Hawtin