What is a better way to implement this if else logic?

Question

I have a problem with getting my logic to work or better still I need a better way to implement this if-else situation.

I have 3 different conditions that set different properties and I want data to be persisted to database only when all conditions evaluate to true and not persist when any or all of the different conditions evaluate to false.

if (a>b){
  em.setAlpha();
}else{
  //throw error that prevents em.persist
}

if (c>d){
  em.setBeta();
}else{
  //throw error that prevents em.persist
}

if (e>f){
  em.setOmega();
}else{
  //throw error that prevents em.persist
}

//Should persist only when all conditions evaluate to true and not 
//persist when one or more of the conditions evaluates to false(throws an error)
database.persist(em);

Answer 1

You would be far better using the and operator :

Note: I'm not entirely sure from the context what your setAlpha functions are, so this may not work. If you clarify this in your original question I will fix it here.

if (a > b && c > d && e > f) {
    em.setAlpha();
    em.setBeta();
    em.setOmega();
    database.persist(em);
}
else {
    // We show up here if one of the conditions was false.
}

Hope this helped. Good luck!

Answer 2

Use a boolean flag:

boolean persist = true;

if (a>b){
  em.setAlpha();
}else{
  persist = false;
}

if (c>d){
  em.setBeta();
}else{
  persist = false;
}

if (e>f){
  em.setOmega();
}else{
  persist = false;
}

if (persist) {
  database.persist(em);
}

Answer 3

If the processing order is fixed, you could use OOP design pattern "Chain Of Responsibility" for this problem. Here is a small program I put together as an illustration:

class JavaObj  {
    public void setAlpha() {}
    public void setBeta() {}
    public void setOmega() {};
}
class DB  {
    public void persist(JavaObj obj) {}
}
abstract class Handler {
    protected Handler successor;
    public void setSuccessor(Handler successor){
        this.successor = successor;
    }
    abstract public boolean processRequest(Integer [] params, JavaObj request);
}
class AlphaHandler extends Handler {
    public AlphaHandler (Handler successor) { setSuccessor(successor); }
    public boolean processRequest(Integer [] params, JavaObj request) {
        if (params[0]>params[1]) {
            request.setAlpha();
            return (successor==null) ? true : successor.processRequest(params, request);
        } else {
            return false;
        }
    }
}
class BetaHandler extends Handler {
    public BetaHandler (Handler successor) { setSuccessor(successor); }
    public boolean processRequest(Integer [] params, JavaObj request) {
        if (params[2]>params[3]) {
            request.setBeta();
            return (successor==null) ? true : successor.processRequest(params, request);
        } else {
            return false;
        }
    }
}
class OmegaHandler extends Handler {
    public OmegaHandler (Handler successor) { setSuccessor(successor); }
    public boolean processRequest(Integer [] params, JavaObj request) {
        if (params[4]>params[5]) {
            request.setOmega();
            return (successor==null) ? true : successor.processRequest(params, request);
        } else {
            return false;
        }
    }
}
public class ChainOfResponsibilityAsExample {
    // setup the chain of responsibilities 
    private static Handler omegaHandler = new OmegaHandler(null);
    private static Handler betaHandler = new BetaHandler(omegaHandler);
    private static Handler processor = new AlphaHandler(betaHandler);

    public static void main(String[] args) {
         DB database = new DB();
         JavaObj em = new JavaObj();
         Integer[] intArray = new Integer[] { 0, 1, 2, 3, 4, 5 };

         if (processor.processRequest(intArray, em)) {
             database.persist(em);
         }
     }
}

Answer 4

You could do this, using and to shorten your code:

// We set the valid ones
if (a > b) {
    em.setAlpha();
} else {
    //throw error that prevents em.persist
}
if (c > d) {
    em.setBeta();
} else {
    //throw error that prevents em.persist
}
if (e > f) {
    em.setOmega();
} else {
    //throw error that prevents em.persist
}

public boolean validate() {
    if ((a > b) && (c > d) && (e > f)) {
        return true;
    } else {
        return false;
    }
}

if (validate()) {
    database.persist(em);
}

After that you can call if validate() to check conditions more quickly as well.