Otimização de problemas aninhados em várias camadas de instruções condicionais, ajuda você a escrever código que não deixa os colegas reclamarem

O artigo foi publicado pela primeira vez na conta pública (Moon with Feiyu) e depois sincronizado com o site pessoal: xiaoflyfish.cn/

Se você gostar, compartilharei mais séries de artigos no futuro!

Eu sinto que ganhei algo, espero ajudá-lo a gostar, encaminhe, obrigado, obrigado

• Pesquisa WeChat: Flying Fish on the Moon, faça amigos, participe do grupo de troca de entrevistas

Responda ao 666 no fundo da conta oficial, você pode obter e-books gratuitos

prefácio

No "Manual de Desenvolvimento do Alibaba", há sugestões e soluções sobre vários ramos if-else e aninhamento, como segue:

Portanto, este artigo apresenta vários esquemas de otimização para fornecer algumas ideias

caso

O seguinte é um código típico que você pode encontrar no desenvolvimento:

public String getTweetTitle(int type) {
        String result;
        if (type == 0) {
            throw new IllegalArgumentException("参数有误");
        }

        //长贴-->获得长帖标题
        if (isPaperTweet(type)) {
            result = getPaperTweetTitle();
        } else {
            // 视频贴-->获得视频贴标题
            if (isVideoTweet(type)) {
                result = getVideoTitle();
            } else {
                result = getDefaultTitle();
            }
        }
        return result;
    }
复制代码

Nesse caso, como podemos substituir os problemas de aninhamento de várias ramificações e ramificações? Como tornar o código mais fácil de manter e estender?

Você pode pensar sobre isso por si mesmo...  

Abaixo eu forneço alguns métodos

declaração de guarda

O livro "Refactoring - Improving the Design of Existing Code" tem a seguinte descrição:

Se uma condição for extremamente rara, ela deve ser verificada por si mesma e retornada da função assim que a condição for verdadeira. Essas verificações separadas costumam ser chamadas de "declarações do guardião".

Usando instruções guard, podemos modificar o exemplo acima para:

public String getTweetTitle(int type) {
        // 条件检查
        if (type == 0) {
            throw new IllegalArgumentException("参数有误");
        }

        // 长贴-->获得长帖标题
        if (isPaperTweet(type)) {
            return getPaperTweetTitle();
        }

        // 视频贴-->获得视频贴标题
        if (isVideoTweet(type)) {
            return getVideoTitle();
        }

        return getDefaultTitle();
    }
复制代码

Verifique a condição primeiro e, em seguida, converta a lógica if-else no formato de instrução de guarda correspondente.

enumerar

"Effective Java Chinese Edition" no artigo 30: Use enum em vez de int constante seção tem uma descrição: Use enumeração para substituir declaração de ramificação, embora perca a simplicidade, é mais seguro e mais flexível.

Ao definir uma função abstrata dentro da enumeração, cada constante de enumeração substitui a função, de modo que o resultado do cálculo esperado pode ser obtido chamando a função após obter a constante de enumeração de acordo com o valor de enumeração.

O código de exemplo é o seguinte:

public enum TweetStrategyEnum {

    PAPER(1) {
        @Override
        double getTitle() {
            return "长贴标题";
        }
    },
    VIDEO_TWEET(2) {
        @Override
        double getTitle() {
            return "视频贴标题";
        }
    },
    DEFAULT_TWEET(3) {
        @Override
        double getTitle() {
            return "短贴标题";
        }
    };

    private final int type;

    TweetStrategyEnum(int type) {
        this.type = type;
    }

    abstract String getTitle();

    public static TweetStrategyEnum valueOf(int type) {
        for (TweetStrategyEnum tweetStrategyEnum : TweetStrategyEnum.values()) {
            if (tweetStrategyEnum.type == type) {
                return tweetStrategyEnum;
            }
        }
        return null;
    }
}
复制代码

Ao usar, obtenha o objeto de enumeração de acordo com o valor de enumeração e chame diretamente a estratégia correspondente à constante de enumeração:

public void getTitle() {
        TweetStrategyEnum tweetStrategyEnum = TweetStrategyEnum.valueOf(1);
        if(tweetStrategyEnum != null){
            System.out.println(tweetStrategyEnum.getTitle());
        }
    }
复制代码

modo de estado

O capítulo Zen of Design Patterns afirma:

Uma das vantagens do padrão de estado é a "estrutura clara". O modo de estado incorpora o princípio aberto-fechado e o princípio de responsabilidade única e é fácil de expandir e manter.

A chamada estrutura clara é evitar o uso de muitas instruções switch-case ou if-else, evitar a complexidade do programa e melhorar a capacidade de manutenção do programa.

O caso fornecido pelo livro "Zen of Design Patterns" é muito semelhante ao apresentado no artigo. Diferentes comportamentos são executados de acordo com o estado atual. Se você estiver interessado, pode pesquisar.

Otimize também o código do caso acima:

Definir uma interface de comportamento de estado

public interface TweetState {
    String getTitle();
}
复制代码

Definir várias implementações de estado concreto

public class VideoTweetState implements TweetState{
    @Override
    public String getTitle() {
        return "视频贴";
    }
}

public class PaperTweetState implements TweetState{
    @Override
    public String getTitle() {
        return "长贴标题";
    }
}

public class DefaultTweetState implements TweetState{
    @Override
    public String getTitle() {
        return "短贴标题";
    }
}
复制代码

Definir um cliente para uso do estado

public class Client {

    private TweetState tweetState;

    public TweetState getTweetState() {
        return tweetState;
    }

    public void setTweetState(TweetState tweetState) {
        this.tweetState = tweetState;
    }

    public void getTitle() {
        tweetState.getTitle();
    }
}
复制代码

Uso externo

public static void main(String[] args) {
        Client client = new Client();
        client.setTweetState(new VideoTweetState());
        client.getTitle();
    }
复制代码

Estratégia + Padrão de Fábrica

Primeiro, abstraímos cada bloco de código lógico condicional em uma interface pública, podemos obter o seguinte código:

public interface ITweetService {
    String getTitle();
}
复制代码

De acordo com cada condição lógica, definimos a classe de implementação da estratégia correspondente, e o seguinte código pode ser obtido:

public class PaperTweetServiceImpl implements ITweetService{
    @Override
    public String getTitle() {
        return "长贴标题";
    }
}

public class VideoTweetServiceImpl implements ITweetService{
    @Override
    public String getTitle() {
        return "视频贴标题";
    }
}
复制代码

Em seguida, definimos a classe de fábrica de políticas para gerenciar essas classes de política, da seguinte forma:

public class TweetServicesFactory {

    private static final Map<String, ITweetService> map = new HashMap<>();
    static {
        map.put("paperTweet", new PaperTweetServiceImpl());
        map.put("videoTweet", new VideoTweetServiceImpl());
    }
    public static ITweetService getTweetService(String type) {
        return map.get(type);
    }
}
public static void main(String[] args) {
        ITweetService tweetService = TweetServicesFactory.getITweetService(1);
        tweetService.getTitle();
    }
复制代码

Resumir

Este artigo fala principalmente sobre como resolver a expansão da instrução if-else e problemas de aninhamento de vários níveis. Pode ser resolvido por instrução de guarda, enumeração, modo de estado, estratégia + modo de fábrica, etc. Se você tiver uma solução melhor, pode se comunicar comigo

Espero que você possa tentar usar esses métodos no desenvolvimento real para escrever um código mais elegante.

finalmente

Sinta-se bem, lembre-se de curtir, encaminhar, compartilhar, obrigado

Pesquisa WeChat: Flying Fish on the Moon, faça amigos, participe do grupo de troca de entrevistas

Responda ao 666 no fundo da conta oficial, você pode obter e-books gratuitos