Lo primero y más importante: el código debe ir siempre entre etiquetas de Código GeSHi y a ser posible para el lenguaje apropiado y correctamente indentado. En tu caso deberías escribir:
[code=java]
Aqui escribes tu código
[/code]

Ahora antes de comentar el problema, voy a comentar la descripción de este:
Problemas con esa descripción (para la parte en negrita concretamente):
1 - ¿Qué se entiende por diagonal principal? Si se entiende por diagonal principal únicamente la que empieza en la posición (0,0) y continúa por (1,1), (2,2),...(n,n); únicamente existe una diagonal principal en cada matriz cuadrada por lo que eso de "CADA diagonal" confunde un poco.
Si por el contrario, se refiere a todas las diagonales menores que son paralelas a la diagonal principal, entonces tu programa tiene otro problema y es que sólo evalúas la diagonal principal mayor.
2 - "Cuando M = N"... Si es una aclaración de lo que es la diagonal principal, entonces sólo existe una y el "CADA diagonal" estaría fuera de lugar. Otra interpretación es que el programa sólo analice las matrices cuadradas, es decir, que haga todo lo que se pide únicamente cuando M sea igual a N.

Para no complicarme supondré una única diagonal principal por matriz ya sea ésta última cuadrada o no.

Ahora yendo al problema principal, no entiendo qué hace tu método diagonales() que muestro a continuación y que he ido añadiendo comentarios en todo aquello que tenía que comentar:

public static void diagonales(){
    // Si solo vas a recorrer la diagonal principal basta con hacer un for(int i = 0; i < menor(m,n); i++) y utilizar num[i][i]
    for(int i=0; i<m;i++){
        for(int k=0; k<n;k++){
            if(i==k){
                CapicuaNumero=0;
                auxMayor=0;
                auxCapicuaPrincipal=num[i][k];
                // Aqui empiezas a quitar el ultimo digito al numero pero...
                while(auxCapicuaPrincipal>0){
                    cifra = auxCapicuaPrincipal%10;
                    auxCapicuaPrincipal=auxCapicuaPrincipal/10;
                    //CapicuaNumero = 0
                    NumeroPrincipal=(CapicuaNumero*10)+cifra; // ...CapicuaNumero siempre vale 0, asi que eso siempre es = cifra
                }
                if(NumeroPrincipal==num[i][k]){
                    if(NumeroPrincipal>auxMayor){ // Aqui auxMayor siempre es 0
                        NumeroP = respuestaPrincipal; // Aqui respuestaPrincipal no tiene valor asi que es 0
                    }
                }
                System.out.println("numero capicua"+NumeroP);
            }
            /*if((i+k)==num.length-1){
                auxCapicuaSecundario=num[i][k];
            }*/
        }
    }
    JOptionPane.showMessageDialog(null,"El mas alto numero es "+NumeroP);
} 

Además de los errores, tu código necesita mucha más organización de la que tiene. Muchos de los atributos de la clase no son necesarios y bastaría con utilizar variables locales a su método. Además la asignación de valores a no ser que sean constantes, es mejor que lo dejes para el main() o cualquier otro método y no lo incluyas en la misma declaración de los atributos.
Y como recomendación, crea un método que sea esCapicua(int) y que devuelva true/false según si el número indicado es capicúa o no. Esto te facilitará mucho el trabajo.

public class Principal {
  private static int numFilas;
  private static int numCols;
  private static int[][] matriz;
 
  public static void main(String[] args) {
    numFilas = Integer.parseInt(...);
    numCols = Integer.parseInt(...);
    matriz = new int [numFilas][numCols];
 
    rellenarMatriz();
    System.out.println("----- MATRIZ RESULTANTE -----");
    mostrarMatriz();
 
    int[] capicuasMayores = calcularCapicuasMayores(); // Puedes devolver los dos capicuas mas grandes
    System.out.println("El segundo numero capicua mas grande es: " + capicuasMayores[1]);
  }
 
  private static int[] calcularCapicuasMayores() {
    int capicuas[] = new int[2]; // En capicuas[0] se guarda el mayor y en capicuas[1] el segundo mayor
    boolean primerCapicua = true; // Flag para saber si es el primer capicua que guardamos. Si es negativo no vale comparar con > 0
    int dimensionMenor = numFilas < numCols ? numFilas : numCols;
    int numeroActual;
    for(int i = 0; i < dimensionMenor; ++i) {
      numeroActual = matriz[i][i];
      if(esCapicua(numeroActual)) {  
        if(primerCapicua) {                
          capicuas[0] = numeroActual;
          primerCapicua = false;                           
        } else if(numeroActual > capicuas[0]) {
          capicuas[1] = capicuas[0];
          capicuas[0] = numeroActual;
        } else if(numeroActual > capicuas[1]) {
          capicuas[1] = numeroActual;
        }
    }
    return capicuas;
  }
 
  private static boolean esCapicua(int num) {
    // Esto te toca a ti ya...
    // Si haces que esto devuelva true cuando un numero es capicua y false cuando no, todo funcionara correctamente (creo)
  }
} 

Como ves, es un código organizado en métodos pero que cada uno hace una parte muy concreta y con solo mirar el método main() ya tienes una idea de lo que el programa hace, aunque no sepas cómo lo hace (para eso tendrías que mirar el resto de métodos).