¿Cómo optimizar mi código y reducir la cantidad de condiciones (if)?

Como mencionaron antes hay lugares donde se repiten código.

Por lo que se lee en el código, lo que encesitas es: Devolver -1 si numFI o numFA son numeros negativos

Esto lo puedes ver en el else de tu primer if

if (numFI>=0 && numFA>=0){
    ...
} else {
    return -1;
}

Lo que yo te recomendaria seria invertir el primer if. Creando la condicion en la que entra al else anterior. Entonces analizando tu primer if vemos que lo que tu quieres es que numFI y numFA sean los dos positivos. O sea que si uno de los dos o los dos son negativos entrariamos al else. Y quedaria asi.

if(numFI < 0 || numFA <0){
    return -1;
} else {
    ...
}

Y luego iriamos a analizar el resto de codigo que tenias en tu primer if.

if (numFI == numFA) {
  if (numFI == 0) {
    return numFI + 1;    
  }
  return numFI  + 1;
} else if (numFI > numFA) {
  return numFI + 1;
} else if (numFA > numFI) {
  return numFA + 1;
} else {
  return -1;
}

Al analizar este pedazo de codigo, lo que necesitas hacer es devoler el numero entre numFI y numFA mas alto mas 1. Esto se logra facil on una operacion ternaria. de la siguiente manera.

return (numFI > numFA ? numFI : numFA) + 1;

Al ser numFI el numero mas grande retornariamos numFI + 1. Y si numFI no es el numero mas grande quiere decir que:

• numFA > numFI
• numFA = numFI

En cualquiera de los casos podemos retornar numFA + 1. Y agrupando todo tu funcion te quedaria de la siguiente manera.

public obtenerNum() {
long numFI = daoF.getNumFI();
long numFA = daoF.getNumFA();

if(numFI < 0 || numFA <0) {
    return  -1;
}

return (numFI > numFA ? numFI : numFA) + 1;
}

Si sigues teniendo dudas, sigue preguntando, para eso esta la comunidad y sigue adelante.

Hay ciertas zonas de tu código que son innecesarias o se pueden agrupar.

Por ejemplo, esta condición es innecesaria:

if (numFI == 0) {
    return numFI + 1;    
}
return numFI + 1;

Esta comprobación comprueba si numFI vale 0 para devolver el valor numFI + 1, que es el mismo valor que hubiera devuelto si no se cumple la condición.

Los dos últimos else también se pueden combinar:

if (...) {
  if (...) {
    ...
  } else {
    return -1;
  }
} else {
  return -1;
}

Aplicando estas dos mejoras podrías reducir tu código a éste:

public long obtenerNum() {
  long numFI = daoF.getNumFI();
  long numFA = daoF.getNumFA();

  if (numFI >= 0 && numFA >= 0) {
    if (numFI == numFA) {
      /* Nos ahorramos una condición */
      return numFI + 1;
    } else if (numFI > numFA) {
      return numFI + 1;
    } else if (numFA > numFI) {
      return numFA + 1;
    }
  }
  /* Si la ejecución llega a este punto (los dos else) devolvemos -1 */
  return -1;
}

Pero si analizamos el funcionamiento del programa en su conjunto, y no línea a línea, comprenderemos que siempre que numFI y numFA sean mayores que 0 se devolverá el valor del número más alto más uno.

De modo que podríamos ahorrarnos la mayoría de condiciones calculando el valor mayor, por ejemplo, haciendo uso de Math.max() en vez de hacerlo mediante condiciones if:

public long obtenerNum() {
  long numFI = daoF.getNumFI();
  long numFA = daoF.getNumFA();

  if (numFI >= 0 && numFA >= 0) {
    return Math.max(numFI, numFA) + 1;
  }
  return -1;
}

Por último, recordarte un detalle: necesitas indicar el tipo de dato devuelto por el método de la clase. He editado mi respuesta para agregar el tipo devuelto en mis ejemplos.

Además, puedes probar en línea el correcto funcionamiento del código (alojado en github) usando Gitpod: