Why is call to static method in Java not being made?

I have a fairly standard creational pattern whereby a class exposes a static method for returning instances of itself, like so:

public class MyClass {

    private MyClass(/*parameter list*/) {
        // internal construction
    }    

    public static MyClass GetMyClass(/*parameter list*/) {
        return new MyClass(/*parameter list*/);
    }
}

...

//this line wont b开发者_如何学编程reak in the debugger and seemingly never gets called - why?
MyClass inst = MyClass.GetMyClass(/*parameter list*/);

However, inst is always null. I can't break on the line that calls the static method, the debugger just ignores it - what's going on?

Edit: Thanks for the suggestions.

• All projects have been cleaned and rebuilt (manully in NetBeans)
• I have added a break in the static method and no it isn't hit.
• Yes, the code above is being called (ultimately) in a constructor for a Swing 'FrameView' though it surely shouldn't matter where I am calling this from, should it?
• There is no exception swallowing anywhere

Side note, other than the missing class declaration (which was a typo) why is this not valid Java? Why is this obviously C# code? Explanations would be more helpful than downvotes :)

Edit II: The Params is just supposed to indicate a whole load of parameters - sorry if this confused anyone, I obviously know parameters have type declarations and so on, the code above was intended as a quick shorthand version rather than a full and (complicated) real sample...

---

A couple of options:

• An exception is being thrown which you're somehow missing
• You're not debugging the code that you think you are (i.e. your built code is out of date with your source code)

The latter is the most likely one, IMO.

---

Apparently you're swallowing an exception inside the constructor something like:

try {
    // Something.
} catch (Exception e) {
}

You should never do that. It makes debugging and nailing down the root cause much harder. Rather throw it or at least do a e.printStackTrace(). If throwing and you don't want to use the throws clause for some reasons, consider using a RuntimeException (or one of its subclasses). E.g.

try {
    // Something.
} catch (Exception e) {
    throw new RuntimeException("Construction failed.", e); // Try to be more specific, e.g. IllegalArgumentException or so. Or just write robust code, i.e. nullchecks and so on.
}

or (but in my opinion not very applicable in your case):

try {
    // Something.
} catch (Exception e) {
    e.printStackTrace();
}

---

I understand that you are trying to make a simple example to show your problem, however if you add the appropriate type statements into your sample code, then it both compiles and does what you expect.

However, in your original codebase you could simply place the breakpoint in the static method to see whether or not it is called.

Maybe a simple question, but you never know… are you sure that you are running the code that you think you are running? That is, is everything recompiled and built from the latest sources?

---

There is nothing wrong with :

MyClass inst = MyClass.GetMyClass(Params);

It depends what is before or after that line of code.

---

Start by doing this:

public class MyClass 
{
    private MyClass(/*parameter list*/) 
    {
        System.out.println("entering MyClass(...)");
        // internal construction
        System.out.println("leaving MyClass(...)");
    }    

    // Java uses lower case for method names - so get not Get
    public static MyClass getMyClass(/*parameter list*/) 
    {
        final MyClass foo;

        System.out.println("entering getMyClass(...)");

        foo = new MyClass(...);

        System.out.println("leaving getMyClass(...)");

        return (foo);
    }
}

...

MyClass inst = MyClass.getMyClass(/*parameter list*/);

See if outside the debugger the code gets called.

If you are catching any exceptions, at the very least do:

catch(final WhateverException ex)
{
    // at the very least do this so you can see that the exception happens
    ex.printStackTrace();
}

Avoid catching Throwable, Error, Exception, and RuntimeException. Infact the best way do do it is get rid of all the catch statements and then only add catches for what the compiler tells you that you have to have.

The other thing is you do not say where MyClass inst = MyClass.getMyClass(/parameter list/); is called from. It is entirely possible that that line never gets hit.

---

You mention that you're calling this from the constructor of a FrameView, but I assume you're talking about an implementation or extension of that interface/object. My reasoning was to make sure you wern't recursively invoking the constructor.

---

I think the reason why catching java.lang.Exception isn't catching the problem is because it is likely too specific in this case. Try catching java.lang.Throwable which will catch errors like java.lang.NoClassDefFoundError - that frequently crops up when you have a jar missing somewhere.