recursive fill sudoku java

import java.util.Arrays;
public class Solver {
private final int SIZE = 4;
private final int AREA = 2;
private int[][] grid = new int[][]{
    {0, 3, 0, 0},
    {0, 1, 0, 2},
    {0, 2, 0, 1},
    {0, 0, 0, 0}};
public int[][] getGrid(){
    return this.grid;
}
public void setCell(int i, int j, int value){
    this.grid[i][j] = value;
}
public void fill(){
    for (int i = 0; i<SIZE; i++){
        for (int j = 0; j<SIZE; j++){
            if (grid[i][j] != 0)
                continue;
            int[] supposedNums = getSupposedNums(i,j);
            for (int k = 0; k<supposedNums.length; k++){
                grid[i][j] = supposedNums[k];
                System.out.println(Arrays.deepToString(grid));
                fill();
            }
        }
    }
}
public int[] getSupposedNums(int i, int j){
    int[] tempArr;
    int[] result = new int[SIZE];
    for (int k = 0; k<SIZE; k++){
        result[k] = k+1;
    }
    //if row, column, area contain num then delete from result array
    tempArr = getColumn(i);
    for (int n = 1; n<=SIZE; n++){
        if (Arrays.toString(tempArr).contains(Integer.toString(n)))
            result[n-1] = 0;
    }
    tempArr = getRow(j);
    for (int n = 1; n<=SIZE; n++){
        if (Arrays.toString(tempArr).contains(Integer.toString(n)))
            result[n-1] = 0;
    }
    tempArr = getArea((int)i/AREA,(int)j/AREA);
    for (int n = 1; n<=SIZE; n++){
        if (Arrays.toString(tempArr).contains(Integer.toString(n)))
            result[n-1] = 0;
    }
    //del 0 from array
    while(findInArray(result,0) >= 0) {
        result = delFromArray(result, findInArray(result,0));
    }
    return result;
}
public int[] addToArray(int[] arr, int value){
    int[] temp = new int[arr.length+1];
    System.arraycopy(arr,0,temp,0,arr.length);
    temp[temp.length-1] = value;
    return  temp;
}
public static int[] delFromArray(int[] arr, int index){
    if (arr.length<=index)
        return null;
    int[] temp = new int[arr.length-1];
    for (int i = 0, j = 0; i < arr.length; i++,j++){
        if (i == index){
            i++;
            if (i == arr.length)
                continue;
        }
        temp[j] = arr[i];
    }
    return temp;
}
public int findInArray(int[] arr, int value){
    for (int i =0;i<arr.length;i++)
        if (arr[i] == value)
            return i;
    return -1;
}
public int[] getRow(int row){
    int[] result = new int[SIZE];
    for (int n = 0; n<SIZE; n++){
        result[n] = grid[row][n];
    }
    return result;
}
public int[] getColumn(int column){
    int[] result = new int[SIZE];
    for (int n = 0; n<SIZE; n++){
        result[n] = grid[n][column];
    }
    return result;
}
public int[] getArea(int row, int column){
    int[] res = new int[SIZE];
    if (AREA*row > SIZE || AREA*column > SIZE) return res;
    for (int m=0; m<AREA; m++){
        for (int n=0;n<AREA;n++){
            res[m*AREA+n] =grid[AREA*row+m][AREA*column+n];
        }
    }
    return res;
}
}

getSupposedNums(i,j) возвращает массив возможных вариантов для ячейки i,j, работает корректно.

fill() работает не так как хотелось бы, тк заполняет просто рандомными числами от 1 до SIZE. Отдельно без рекурсии все работает отлично, я так понял что это связано с областью видимости в рекурсии.