Reducing Excessive if‑else Nesting in Java Sharing Modules

Deeply nested if else statements make Java code hard to read, test, and maintain, especially in sharing modules that handle multiple content types such as links, images, text, and image‑text.

The author first shows a typical implementation with many nested branches, then proposes three strategies to eliminate the excessive nesting.

Method 1: Interface Layering

Separate the public API from internal logic: the outer share method performs null checks and delegates to a private shareImpl method, reducing repeated validations.

public void share(ShareItem item, ShareListener listener) {
    if (item == null) {
        if (listener != null) {
            listener.onCallback(ShareListener.STATE_FAIL, "ShareItem 不能为 null");
        }
        return;
    }
    if (listener == null) {
        listener = new ShareListener() {
            @Override
            public void onCallback(int state, String msg) {
                Log.i("DEBUG", "ShareListener is null");
            }
        };
    }
    shareImpl(item, listener);
}

private void shareImpl(ShareItem item, ShareListener listener) {
    // original nested if‑else logic
}

Method 2: Polymorphism

Define an abstract ShareItem with a doShare method, then create concrete subclasses ( Link, Image, Text, ImageText) that implement their own sharing behavior, eliminating business‑level branching.

public abstract class ShareItem {
    int type;
    public ShareItem(int type) { this.type = type; }
    public abstract void doShare(ShareListener listener);
}

public class Link extends ShareItem {
    String title, content, link;
    public Link(String link, String title, String content) {
        super(TYPE_LINK);
        this.link = !TextUtils.isEmpty(link) ? link : "default";
        this.title = !TextUtils.isEmpty(title) ? title : "default";
        this.content = !TextUtils.isEmpty(content) ? content : "default";
    }
    @Override
    public void doShare(ShareListener listener) { /* share link */ }
}
// Similar classes for Image, Text, ImageText

The public share method now simply calls item.doShare(listener), keeping the API clean.

Method 3: Map‑Based Dispatch

Store the concrete ShareItem classes in a Map<Integer, Class<? extends ShareItem>> and instantiate them via reflection, removing explicit if else checks for the type.

private Map<Integer, Class<? extends ShareItem>> map = new HashMap<>();
private void init() {
    map.put(TYPE_LINK, Link.class);
    map.put(TYPE_IMAGE, Image.class);
    map.put(TYPE_TEXT, Text.class);
    map.put(TYPE_IMAGE_TEXT, ImageText.class);
}

public ShareItem createShareItem(int type) {
    try {
        Class<? extends ShareItem> clazz = map.get(type);
        return clazz.newInstance();
    } catch (Exception e) {
        return new DefaultShareItem(); // fallback
    }
}

Each approach reduces the number of nested if else statements, improves readability, and follows solid design principles such as the Law of Demeter and Open‑Closed Principle.

Additional helper methods (e.g., createLinkShareItem, createImageShareItem) can hide class details from callers, further simplifying the API.