How to return 2 variables from a function

If there is an exception, you should propagate it and let another method handle the problem, this is not the correct way to deal with it. You'll have to deal with the problem, do it right or wrong.

If you want to insist, I think the best way is to create a class just for this (since Java does not give many facilities) whose members will be this list of products and the flag , there in return you deconstruct the class, that is, take each member and use it as you wish (plays in variable, uses if , etc.).

Note that I disagree with each line of this solution but it would be something like this (the codes are not ready for use, it's just a general idea):

public class Resultado {
    public boolean flag; //não faça isto, fiz só para simplificar
    public listProdutos[] produtos; //prefira usar métodos de acesso get e set
    public Resultado(listProdutos[] produtos, boolean flag) {
        this.produtos = produtos;
        this.flag = flag;
    }
}

public Resultado getProdutosWS() {
    try{
        listProdutos[] produtos = ws.getProdutos(prod)
        return new Resultado(produtos, true);
    }catch(RemoteException ex){
        return new Resultado(null, false);
    }
}

public static main() {
    Resultado lista = getProdutosWS();
    if (lista.flag) {
        System.out.println(lista.produtos[0]); //isto é só um exemplo de uso, nada que seja útil
    }
}

The more I look at this, the more I find it strange. I think you should treat the exception, for this example, in main , something like:

public AlgumMetodoConsumidor(TipoDoWS ws, TipoDoProd prod) {
    try {
        listProdutos[] lista = ws.getProdutos(prod)();
        System.out.println(lista); //isto é só um exemplo de uso, nada que seja útil
    } catch (RemoteException ex) {
        //regra básica das exceções: você lida aqui com o problema porque é
        //aqui que você consegue lidar com ele.
        System.out.println("deu erro");
    }
}

Alternative to not having to create a class specific to this. The advantage would be that the class Resultado would be used for every place that needs to return a flag plus another return:

public class Resultado {
    public boolean flag; //não faça isto, fiz só para simplificar
    public Resultado(boolean flag) {
        this.flag = flag;
    }
}

public Resultado getProdutosWS(Resultado resultado) {
    try{
        listProdutos[] produtos = ws.getProdutos(prod)
        resultado.flag = true;
        return produtos;
    }catch(RemoteException ex){
        resultado.flag = false;
        return null;
    }
}

public static main() {
    Resultado resultado;
    listProdutos[] lista = getProdutosWS(resultado);
    if (resultado) {
        System.out.println(lista[0]); //isto é só um exemplo de uso, nada que seja útil
    }
}

I placed GitHub for future reference .

On the other hand, I do not know if it would be enough to check if the list is null . Of course, it depends on the situation.

In Java, when you want a function to return multiple values, you should:

• add these values to an object and then return them
• or change an object that is passed to the function

In your case, you need to clearly define a mostrar class that could have required fields.

public class Mostrar {
    private boolean flag = false;
    private List<String> produtos = null;

}

then returns your object

return new Teste(flag, produtos) ;

It is not an answer itself. But a matter of suggestion. Here's my:

class ListProdutos{
    private boolean isFlag = false;
    public boolean getIsFlag(){ return isFLag; }
    // Construtor sobrecarregado definindo um objeto flag.
    // Supondo que o seu outro construtor tem parâmetros.
    // Esse construtor não faz mais nada, apenas define o flag. 
    public ListProdutos(){
        isFlag = true;
    }
     //Resto da classe...
}

The solution would be to create a isFLag field and overload a constructor to create a flag object.

Assuming there may be several types of error, you can later add a public String flag; field with the error description.

You can not have more than one return in a Java method. In .Net we use output parameters, but Java does not have that too.

You will have to create a different design for your solution.

One option is to retune a complex object:

// encontre um nome mais significativo 
// para esta classe e seus atributos
class Resultado {

    Produto[] listProdutos;
    boolean requestSucesso;
}

Public listProdutos[] getProdutosWS(String prod){
    Resultado resultado = new Resultado();
    try{
        resultado.listProdutos[] produtos = ws.getProdutos(prod)
        resultado.requestSucesso = true;
        return resultado;
    }catch(RemoteException ex){
        resultado.requestSucesso = false;
        return resultado;
    }
}

Another option is not to do the exception handling there, but rather to the getProdutosWS consumer. In this case, the consumer does not check a flag but only believes that if there was no exception, the method returned what it needed.

And a third option is to implement two methods in this class currently publishing getProdutosWS . One method indicates whether the request was successful and another method returns the products.