/* Why? Here is a class with a static field: */

public class Scan { static int i = 0; public static int get(){ return i++; }}

 /* Let's create two instances of it: */

public class Main
{ public static void main( java.lang.String[] args ) throws java.lang.Exception
 { final java.lang.Class instance1 = new ScanLoader().loadClass( "Scan" );
   final java.lang.Class instance2 = new ScanLoader().loadClass( "Scan" );
   final java.lang.Class[] c = new java.lang.Class[]{};
   final java.lang.Object[] o = new java.lang.Object[]{};
   java.lang.System.out.println( instance1.getMethod( "get", c ).invoke( null, o ));
   java.lang.System.out.println( instance1.getMethod( "get", c ).invoke( null, o ));
   java.lang.System.out.println( instance2.getMethod( "get", c ).invoke( null, o ));
   java.lang.System.out.println( instance2.getMethod( "get", c ).invoke( null, o )); }}

 /* There are really two different static fields, as they can
    count independently:

0
1
0
1

    The rest of the code: */

class ScanLoader extends ClassLoader
{ public ScanLoader()
 { super(ScanLoader.class.getClassLoader()); }
 public java.lang.Class<?> loadClass( final java.lang.String className)
 throws ClassNotFoundException
 { return findClass( className ); }
 public java.lang.Class<?> findClass( final java.lang.String className )
 { byte classByte[];
   java.lang.Class<?> result = null;
   if( "java.lang.Object".equals( className ))return java.lang.Object.class;
   try
   { java.lang.String classPath =
     ((java.lang.String)ClassLoader.getSystemResource
     ( className.replace( '.', java.io.File.separatorChar ) + ".class" ).getFile() ).
     substring( 1 );
     classByte = loadClassData(classPath);
     result = defineClass(className,classByte,0,classByte.length,null);
     return result; }
   catch(final java.lang.Exception e){ throw new java.lang.RuntimeException(e); }}
 private byte[] loadClassData
 ( final java.lang.String className )
 throws java.io.IOException
 { final java.io.File f = new java.io.File( className );
   final int size =( int )f.length();
   final byte buff[] = new byte[ size ];
   { java.io.FileInputStream fis = new java.io.FileInputStream( f );
     { java.io.DataInputStream dis = new java.io.DataInputStream( fis );
       dis.readFully( buff );
       dis.close(); }}
   return buff; }}

    (Please quote enough context to make your message
understandable on its own.)

    For those who haven't seen what's gone before, Woot4Moo
has a BankAccount class that contains a `private static int pin'
variable and a `static int checkPin()' method.  He's wondering
why all BankAccounts have the same pin value, and he's been
advised (by me and others) to get rid of `static'.

    Back to the action: Woot4Moo, I suggested that you get
rid of `static' "in both places," meaning both on the declaration
of the pin variable and on the checkPin() method.  From your
vague description of the problem, I suspect you have eliminated
only one occurrence of `static'.

    If you have eliminated both and are still having trouble,
please post a *complete* self-contained example of the code
and the *exact* text of any error messages you receive.  We're
not mind readers.

And thus spoke Woot4Moo@gmail.com...

public double getBalance(String nameOfOwner, int finalPin)
{
int pin = BankAccount.checkPin();

THIS won't work, of course, if you make the pin non-static (as it should
be). You will need something like...

public double getBalance(Account account, int finalPin)

...or...

public double getBalance(String nameOfOwner, int finalPin)
{
BankAccount account = ... // Somehow get the account of the owner
int pin = account.checkPin();

Oh, and btw: As your method "checkPin" doesn't really "check" the pin,
justs gets it, I would call it "getPin" instead. checkPin would be more
something like...

boolean checkPin(int accountPin, int givenPin) {
if (accountPin == givenPin) {
 return true;
}
return false;
}

Flo

Most  appreciated even though I did think that those were 2 seperate
classes my eyes must really be going.

You seem to have grasped the most important point, that learning to
program is a cumulative process, and you will need to understand the
first semester material in order to understand what follows.

Perhaps you should try applying the advice so far, and post you new best
effort, working or not. Do copy-paste, without retyping, so that we get
to see exactly what you are doing.

The newsgroup, collectively, has a lot of experience at working out what
concepts, if any, someone is missing from their code attempts.

Patricia