Método recursivo para verificar matriz identidade

Programação Java
#1

Olá, preciso fazer um método recursivo para verificar se uma matriz de inteiros é uma matriz identidade.

Ex da matriz identidade

1 0 0 0
0 1 0 0
0 0 1 0
0 0 0 1

Fiz meu método assim

 public static boolean isIdentidade(int[][] m) {
        if (m == null) {
            throw new NullPointerException();
        }
        if (m.length != m[0].length) {
            throw new IllegalArgumentException();
        }
        return isIdentidade(m, 0, 0);
    }

    private static boolean isIdentidade(int[][] m, int i, int j) {
        if (i >= m.length) {
            return true;
        }
        if (m[i][j] != 1) {
            return false;
        }

        return isIdentidade(m, i+1, j + 1);
    }

Ele funciona parcialmente, ele verifica as posições dos 1, porém não consigo fazer ele verificar se o restante é zero. No exemplo da matriz acima ele retorna true ou falso caso algum elemento 1 estiver fora da posição certa, porém se a matriz for assim ele vai retornar true igual:

1 0 1 0
0 1 0 0
1 0 1 0
0 1 0 1

#2 
package teste;

public class Teste {

    public static void main(String[] args) {

        int[][] matriz = {
            {1, 0, 0, 0},
            {0, 1, 0, 0},
            {0, 0, 1, 0},
            {0, 0, 0, 1}
        };

        System.out.println("comRecursividade(): " + comRecursividade(matriz));
        System.out.println("Sem é melhor ->  isMatrizIdentidade(): " + isMatrizIdentidade(matriz));

    }

    private static boolean isDiagonalCompativel(int[][] matriz) {
        for (int linha = 0; linha < matriz.length; linha++) {
            if (matriz[linha][linha] != 1) {
                return false;
            }
        }
        return true;
    }

    public static boolean comRecursividade(int[][] matriz) {
        return comRecursividade(matriz, 0, isDiagonalCompativel(matriz));
    }

    private static boolean comRecursividade(int[][] matriz, int linha, boolean continuar) {
        if (!continuar) {
            return false;
        }

        for (int coluna = 0; coluna < matriz[linha].length; coluna++) {
            if (linha == coluna) {
                continue;
            }
            if (matriz[linha][coluna] != 0) {
                return false;
            }
        }
        return ++linha < matriz.length ? comRecursividade(matriz, linha, continuar) : true;
    }

    public static boolean isMatrizIdentidade(int[][] matriz) {
        if (!isDiagonalCompativel(matriz)) {
            return false;
        }

        for (int linha = 0; linha < matriz.length; linha++) {
            for (int coluna = 0; coluna < matriz[0].length; coluna++) {
                if (linha == coluna) {
                    continue;
                }
                if (matriz[linha][coluna] != 0) {
                    return false;
                }
            }
        }
        return true;
    }
}