This is because a double[][] is an array of double[] which you can't assign 0.0 to (it would be like doing double[] vector = 0.0). In fact, Java has no true multidimensional arrays.

As it happens, 0.0 is the default value for doubles in Java, thus the matrix will actually already be filled with zeros when you get it from new. However, if you wanted to fill it with, say, 1.0 you could do the following:

I don't believe the API provides a method to solve this without using a loop. It's simple enough however to do it with a for-each loop.

double[][] matrix = new double[20][4];

// Fill each row with 1.0
for (double[] row: matrix)
    Arrays.fill(row, 1.0);

Arrays in Java are zero-based, which means they start at index zero, and range until index array.length-1.

Your code starts the row and column at 1—which means you're skipping the initialization of row/column 0. That's probably where at least some of the problems are coming from, since you're using your 5x5 array (rows/columns 0,1,2,3,4) as a 4x4 array (rows/columns 1,2,3,4).

There's also the fact that your Encrypt method doesn't actually make any assignments to the array. You probably want to initialize it like this:

// NOTE: changed return type to void -- this is a side-effect-only method!
public void Encrypt(char Encrypt[][])
{
    // NOTE: use single-quotes for chars. double-quotes are for strings.
    char aChar = 'A';
    // NOTE: changed the starting loop values from `1` to `0`
    for (int row = 0; row < Encrypt.length; row++)
    {
        // NOTE: technically Encrypt.length works here since it's a square
        // 2D array, but you should really loop until Encrypt[row].length
        for (int column = 0; column < Encrypt[row].length; column++)
        {
            // NOTE: set each entry to the desired char value
            Encrypt[row][column] = aChar;
        }
    }   
}

There are several issues with your original code. Look at the NOTE entries in the comments for individual explanations.

No, it doesn't work.

However, all is not lost! You don't even need to have the nested loop. Just do this:

public void FillArray(String[][] SC){
    for (int i = 0; i < SC.length; i++){
        Arrays.fill(SC[i], "-");
    }
}

Using a loop is how you can fill each of the inner arrays separately, but Arrays.fill handles the inner loop for you.

To fill the first row in 2D array, use Arrays.fill, to fill the rest of the rows, use Arrays.copyOf.

Next, it's better to implement separate methods to perform different tasks:

1. Create and fill the grid
2. Print the grid

static String[][] fillGrid(int rows, int cols, String cell) {
    String[][] grid = new String[rows][cols];

    String[] row = new String[cols];
    Arrays.fill(row, cell);
    grid[0] = row;
    for (int i = 1; i < rows; i++) {
        grid[i] = Arrays.copyOf(row, cols);
    }
    
    return grid;
}

static void printGrid(String[][] grid) {
    
    for (int i = 0; i < grid.length; i++) {
        if (i == 0) {
            System.out.print("   ");
            for (int j = 0; j < grid[0].length; j++) {
                System.out.printf("%2d ", j + 1);
            }
            System.out.println();
        }
        for (int j = 0; j < grid[i].length; j++) {
            if (j == 0) {
                System.out.printf("%2d:", i + 1);
            }
            System.out.printf("%2s ", grid[i][j]);
        }
        System.out.println();
    }
}

Then they may be tested like this:

public static void main(String ... args) {
    String[][] grid = fillGrid(8, 8, "x");
    printGrid(grid);
}

The output will be as follows:

    1  2  3  4  5  6  7  8 
 1: x  x  x  x  x  x  x  x 
 2: x  x  x  x  x  x  x  x 
 3: x  x  x  x  x  x  x  x 
 4: x  x  x  x  x  x  x  x 
 5: x  x  x  x  x  x  x  x 
 6: x  x  x  x  x  x  x  x 
 7: x  x  x  x  x  x  x  x 
 8: x  x  x  x  x  x  x  x