How to define Global Array and call in different classes in Java

Whilst the other answers will work fine for your needs, you should never use public static on a mutable (changeable) field - this means that anyone can change the field anywhere in your application and cause unknown behaviour. Primitives (int double float) won't change if you add final modifier, but an Object like an array can have it's contents modified - only the object reference itself will be constant. As a result - the array is mutable, so you shouldn't use public static on it.

It appears that your String[][] is almost meant to represent a table, with the first element in the String[][] being a header, and each other row being a new row in this table. As a result of this, we can turn your String[][] into something more idiomatic.

We can make each row of your String[][] be represented by an instance of a class. There are a few benefits of this, but namely it means that you can look at it and say "this is X", rather than "this is an array of strings".

public class Account {
    private final String name;
    private final String a, b, c, d, e;

    public Account(String name, String a, String b, String c, String d, String e) {
        this.a = a;
        this.b = b;
        this.c = c;
        this.d = d;
        this.e = e;
        this.name = name;
    }

    public string getName() { return this.name; }
    public string getA() { return this.a; }
    public string getB() { return this.b; }
    public string getC() { return this.c; }
    public string getD() { return this.d; }
    public string getE() { return this.e; }
}

This encapsulates those fields inside of an object. This is great because it means that first of all, you have control over where your fields are assigned and where they can be changed as well.

Now, we can turn your String[][] into an Account[]. As mentioned above, sharing an array directly is bad practise. How do we get around this? Well, we can create another class that controls the lifetime of these accounts. Since it is a data store, let's call it a repository (NB: This is known as the repository pattern).

public class AccountRepository {
    private final Collection<Account> accounts;
    public AccountRepository(Collection<Account> accounts) {
        this.accounts = accounts;
    }

    public Account getByName(String accountName) {
        // Note that this is very inefficient, and I would not recommend using it in real code
        for(Account account : this.accounts) {
            if(account.getName().equalsIgnoreCase(accountName)) {
                return account;
            }
        }
        // Note: Returning null vs throwing exception is out of scope of this example.
        return null;
    }

    public Iterator<Account> getAccounts() {
        return this.accounts.getIterator();
    }
}

Now this gives us a data store that could potentially be used to store any number of Accounts and from, potentially, any source - we don't need to worry about passing around arrays because we can pass an instance of this around, and the best bit is that we give interested parties an Iterator<Account> and not an Account[]. The reason this is great is because Iterators are immutable - you cannot change them. Seeing this, now, we can create your other two classes (Staff, and Customers - whose names and purposes are another subject for debate outside of this question) and tell them that they don't need to worry about an String[][] - they can just take an instance of AccountRepository in their constructor.

public class Customers {
    private final AccountRepository accountRepository;
    public Customers(AccountRepository accountRepository) {
        this.accountRepository = accountRepository;
    }

    public void method1() {
        // do something
    }
}

public class Staff {
    private final AccountRepository accountRepository;
    public Staff(AccountRepository accountRepository) {
        this.accountRepository = accountRepository;
    }

    public void method1() {
        // do something
    }
}

This makes your code a lot more flexible and maintainable and easy to follow. Your Staff and Customers instances would require an AccountRepository to be created, which could be the same one, and those classes would call the methods on the AccountRepository to access the data safely without opportunity for it being changed.

Account[] accounts = new Account[] {
    new Account("Account1", "1", "2", "3", "4", "5"),
    // the rest of the accounts
};

AccountRepository repository = new AccountRepository(Arrays.asList(accounts));
Customers customers = new Customers(repository);
Staff staff = new Staff(repository);

In my opinion you should always try to avoid "static" properties or fields - the usage of which indicates a code smell the majority of the time.

Hope this helps and doesn't confuse you.