I'm fumbling again. I'm trying to write this Sudoku solver to work up
my java skills. What I thought to do was to create a fairly static
subroutine to set up the board with values until I have time to master
the gui interface. So I thought I should write a separate class
SudokuSetUp to contains this code, then later I can write the GUI code
in there. I didn't want to write this in my main class the SudokuGame.

But now I can't figure out how to pass the entire array that is the
board over to the other class to insert values into some of the cells.

I tried

  sudokuBoard = SudokuSetup(sudokuBoard);

but that complained that it could not find the method SudokuSetup in my
SudokuGame class.

Then I tried

  sudokuBoard = SudokuSetup.setvalues(sudokuboard)

but that complained that non-static method setValues(SudokuCell[][])
cannot be referenced from a static context

I''m posting my code here, apologies if it is too much code.

Class SudokuGame:

import java.text.*;
import java.util.*;

public class SudokuGame
{
    public static void main (String[] args)
    {

        SudokuCell[] [] arrSudokuBoard = new SudokuCell[9] [9];

//        set up a board with all cells initialized.
        for (int i=0; i<9; i++)
        {
            for (int j=0; j<9; j++)
            {
                arrSudokuBoard[i] [j] = new SudokuCell( i, j);
            }
        }

//      set certain cells to specific values
        arrSudokuBoard = SudokuSetUp.setValues(arrSudokuBoard);

//      print current board
        for (int i=0; i<9; i++)
        {
            System.out.println("x-value " + i);
            for (int j=0; j<9; j++)
            {
                System.out.print(arrSudokuBoard[i] [j].toString());
            }

            System.out.println();
        }

    }
}

Class SudokuCell:
import java.util.*;
import java.text.*;

public class SudokuCell
{
    // Declare instance variables
    private int xCoord;
    private int yCoord;
    private int xRegionCoord;
    private int yRegionCoord;
    List<Integer> cell = new ArrayList<Integer>();

    // Constructor with x,y reference
    public SudokuCell(int x, int y)
    {
        xCoord = x;
        yCoord = y;
        xRegionCoord = xCoord/3;
        yRegionCoord = yCoord/3;
       for (int i=1; i<10; i++)
          {
              cell.add(i);
        }

    }

    public void setValue(int value)
    {
        cell.retainAll(Collections.singleton(value));
    }

    public void removeValue(int value)
    {
        cell.remove(value);
    }

    public int[] getRegion()
    {
        int[] regionCoord = new int[2];
        regionCoord[0] = xRegionCoord;
        regionCoord[1] = yRegionCoord;
        return regionCoord;
    }

    public int [] [] getXAdj()
    {
        int [] [] xAdj = new int [2] [2];
        int pos = xCoord % 3;
        switch (pos)
        {
            case 0:
                xAdj[1] [1] = xCoord + 1;
                xAdj[1] [2] = yCoord;
                xAdj[2] [1] = xCoord + 2;
                xAdj[2] [2] = yCoord;
                break;
            case 1:
                xAdj[1] [1] = xCoord - 1;
                xAdj[1] [2] = yCoord;
                xAdj[2] [1] = xCoord + 1;
                xAdj[2] [2] = yCoord;

                break;
            case 2:
                xAdj[1] [1] = xCoord - 2;
                xAdj[1] [2] = yCoord;
                xAdj[2] [1] = xCoord - 1;
                xAdj[2] [2] = yCoord;
                break;
        }
        return xAdj;
    }

    public int [] [] getYAdj()
    {
        int [] [] yAdj = new int [2] [2];
        int pos = yCoord % 3;
        switch (pos)
        {
            case 0:
                yAdj[1] [1] = xCoord;
                yAdj[1] [2] = yCoord + 1;
                yAdj[2] [1] = xCoord;
                yAdj[2] [2] = yCoord + 2;
                break;
            case 1:
                yAdj[1] [1] = xCoord;
                yAdj[1] [2] = yCoord - 1;
                yAdj[2] [1] = xCoord;
                yAdj[2] [2] = yCoord + 1;

                break;
            case 2:
                yAdj[1] [1] = xCoord;
                yAdj[1] [2] = yCoord - 2;
                yAdj[2] [1] = xCoord;
                yAdj[2] [2] = yCoord - 1;
                break;
        }
        return yAdj;
    }

    public String toString()
    {
        String outString = new String("Cell at
X("+xCoord+"),Y("+yCoord+"):("+cell+")");
        return outString;
    }
}

Class SudokuSetup:

import java.text.*;
import java.util.*;

public class SudokuSetUp
{
    public class SudokuSetup
    {
    }

    public SudokuCell[] [] setValues(SudokuCell board [] [])
    {
        board[0] [0].setValue(1);
        board[2] [0].setValue(9);
        board[3] [0].setValue(3);
        board[7] [0].setValue(2);
        board[0] [1].setValue(7);
        board[2] [1].setValue(3);
        board[3] [1].setValue(6);
        board[4] [1].setValue(2);
        board[5] [1].setValue(5);
        board[6] [1].setValue(1);
        board[1] [2].setValue(2);
        board[3] [2].setValue(1);
        board[8] [2].setValue(7);
        board[1] [3].setValue(6);
        board[3] [3].setValue(8);
        board[5] [3].setValue(1);
        board[1] [4].setValue(5);
        board[2] [4].setValue(2);
        board[6] [4].setValue(8);
        board[7] [4].setValue(7);
        board[3] [5].setValue(2);
        board[5] [5].setValue(3);
        board[7] [5].setValue(5);
        board[0] [6].setValue(4);
        board[5] [6].setValue(2);
        board[7] [6].setValue(3);
        board[2] [7].setValue(6);
        board[3] [7].setValue(7);
        board[4] [7].setValue(3);
        board[5] [7].setValue(8);
        board[6] [7].setValue(4);
        board[8] [7].setValue(2);
        board[1] [8].setValue(3);
        board[5] [8].setValue(9);
        board[6] [8].setValue(7);
        board[8] [8].setValue(5);

        return board;
    }
}

Thanks
Mike