MVC in Java, just need a bit of pointing in the right direction

There's a couple of questions here, I'll try to break them down and answer at least some of them:

First, to be able to call instance methods of A, you need to provide the instance to B when its instantiated. The following example does exactly this:

public class A {
    public static void main(String[] args) {
        new A().run();
    }
    public void run() {
        B b = new B(this);
        b.run();
    }

    public void foo() {
        System.out.println("2.");
    }
}

public class B {
    private final A a;
    public B(A a) { this.a = a; }

    public void  run() {
        System.out.println("1.");
        a.foo();
    }
}
// Output:
// 1.
// 2.

The important difference here is that Java doesn't give you magically access to call stack or "parent" of the current execution target. This means that you really do need to piggyback everything forward to the new instances if you want to call them.

Secondly, as NetBeans pointed out, you can't access non-static members from static contexts. This is best shown with a bit of code:

public class A {
    public static void foo() {}
    public void bar() {}

    public static int i = 0;
    public int j = 1;
}

public class B {
    public static void main(String[] args) {
        A.foo();       // works because foo() is static
        A.bar();       // compile error
        new A().bar(); // works because now you're calling
                       // non-static instance's bar() method.

        // Pretty much the same applies to fields;
        A.i = 2;       // works
        A.j = 2;       // compile error, once again
        new A().j = 2; // works
    }
}

static in Java is pretty much an equivalent of a class global (which makes it a very dangerous keyword in OOP and quite honestly should be avoided at all costs). Almost everything else needs to be accessed in an OOP manner or in other words, through an object instance.

While having a global state for certain things might sound reasonable (such as application's configuration), in the long run it isn't - you're just as good creating a seemingly singleton object that contains configuration state but can be modified on the fly if needed; this way you can avoid restarting the application when the configuration changes.

I hope this helps and answered your questions and don't hesitate to ask even more if needed.

Declaring a method static means that the method is a method of the class, and not a method of the instance of that class. So, obviously, this has no sense in a static method: there is no instance of the class to which this could refer.

What you want is this:

public class ClassA {

    public static void main(String[] args) {
        ClassA a = new ClassA();
        ClassB b = new ClassB(a);
        ...
    }
}

Read the tutorial about static members.

Once you've got past this hurdle (as described by others) you'll see that the ethos of Java supports MVC development. There are even Observer and Observable interfaces that you can implement so that you can easily hook up networks of event-driven objects.

The whole of the Swing framework relies on MVC concepts too, so you'll have an underlying model that you can overlay multiple views on. (You can even consider building your GUI using the same framework that Netbeans is built on so you'd get a lot of reuse of mature GUI components.)

Java is a reasonably complex platform though (though the language is disarmingly simple itself). It's worth reading a book, or having some good reference material to hand before diving into this, to make sure you structure things properly.