Question

我有一个包含3个整数i，j和k的对象。

这些整数可以有一个减号（M），一个加号（P）或者为空（O）。

因此，任何此类对象都可以归类为以下类别之一： MMM，MMP，MPM，MPP，PMM，PMP，PPM，PPP，OMM，OMP，OPM，OPP，MOM，MOP，POM，POP，MMO，MPO，PMO，PPO，MOO，POO，OMO，OPO，OOM， OOP，OOO。

我想对这种类型的对象进行计算，这些对象会根据对象的类别而有所不同。

我的对象不仅包含这三个整数，还包含将在计算中使用的其他信息。

我的两个问题是：

如何从i，j和k值中推断出对象的类别？
如何实现正确算法的选择？

我做了一个天真的实现，使用枚举和很多if ... else，但我对结果不满意，尤其是if ... else部分。

任何更好，更面向对象的想法？

数据类：

public class Data {
    private int i, j, k;
    private double otherData;
    private Category category;

    public void init(int i, int j, int k) {
        this.i = i;
        this.j = j;
        this.k = k;

        if (i < 0) {
            if (j < 0) {
                if (k < 0) {
                    category = Category.MMM;
                } else if (k > 0) {
                    category = Category.MMP;
                } else//(k >= 0)
                {
                    category = Category.MMO;
                }
            } else//(j >= 0)
            {
                if (k < 0) {
                    category = Category.MPM;
                    if (j == 0)
                        category = Category.MOM;
                } else//(k >= 0)
                {
                    if ((j == 0) && (k == 0))
                        category = Category.MOO;
                    else if (k == 0)
                        category = Category.MPO;
                    else if (j == 0)
                        category = Category.MOP;
                    else
                        category = Category.MPP;
                }
            }
        } else//(i >= 0)
        {
            if (j < 0) {
                if (k < 0) {
                    category = Category.PMM;
                    if (i == 0)
                        category = Category.OMM;
                } else//(k >= 0)
                {
                    if ((i == 0) && (k == 0))
                        category = Category.OMO;
                    else if (k == 0)
                        category = Category.PMO;
                    else if (i == 0)
                        category = Category.OMP;
                    else
                        category = Category.PMP;
                }
            } else//(j >= 0)
            {
                if (k < 0) {
                    if ((i == 0) && (j == 0))
                        category = Category.OOM;
                    else if (i == 0)
                        category = Category.OPM;
                    else if (j == 0)
                        category = Category.POM;
                    else
                        category = Category.PPM;
                } else//(k > 0)
                {
                    if (i == 0) {
                        if (j == 0)
                            category = Category.OOP;
                        else if (k == 0)
                            category = Category.OPO;
                        else
                            category = Category.OPP;
                    } else {
                        if ((j == 0) && (k == 0))
                            category = Category.POO;
                        else if (j == 0)
                            category = Category.POP;
                        else if (k == 0)
                            category = Category.PPO;
                        else
                            category = Category.PPP;
                    }
                }
            }
        }
    }

    public void computeSomething() {
        category.computeSomething(this);
    }

    public double getOtherData() {
        return otherData;
    }

    public void setOtherData(double otherData) {
        this.otherData = otherData;
    }
}

枚举类：

public enum Category {
    MMM {
        @Override
        public void computeSomething(Data data) {
            // Do something
        }
    },
    MMP {
        @Override
        public void computeSomething(Data data) {
            // Do something else
        }
    }
    // Omitted code for clarity

    public abstract void computeSomething(Data data);
}

有关完整用例的上下文，请参阅http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.147.2010&rep=rep1&type=pdf

Answer 1

此代码等同于您的init方法：

extension UIButton{
    @IBInspectable var borderColor: UIColor? {
        get {
            return UIColor(CGColor: layer.borderColor!)
        }
        set {
            layer.borderColor = newValue?.CGColor
            layer.borderWidth = 1
        }
    }
}

根据@Robert的建议，您也可以这样做：

public void init(int i, int j, int k) {
    this.i = i;
    this.j = j;
    this.k = k;
    category=Category.valueOf( (i<0?"M":(i==0?"O":"P"))
                              +(j<0?"M":(j==0?"O":"P"))
                              +(k<0?"M":(k==0?"O":"P")));
}

关于计算算法的选择，从枚举中删除它可能是一个好主意，并采取类似的方式：

private void init(int i, int j, int k){
    this.i = i;
    this.j = j;
    this.k = k;
    category = Category.fromInts(i,j,k);
}

enum Category {
        MMM, MMP, MPM, MPP, PMM, PMP, PPM, PPP, 
        OMM, OMP, OPM, OPP, MOM, MOP, POM, POP, 
        MMO, MPO, PMO, PPO, MOO, POO, OMO, OPO, 
        OOM, OOP, OOO;

        static Category fromInts(int i, int j, int k){
            return Category.valueOf( (i<0?"M":(i==0?"O":"P"))
                                    +(j<0?"M":(j==0?"O":"P"))
                                    +(k<0?"M":(k==0?"O":"P")));
        };
}

Answer 2

Q1：这是一种避免创建然后散列字符串的替代方法。

private static Category[] CATEGORIES = {
        MMM, MMO, MMP, MOM, MOO, MOP, MPM, MPO, MPP,
        OMM, OMO, OMP, OOM, OOO, OOP, OPM, OPO, OPP,
        PMM, PMO, PMP, POM, POO, POP, PPM, PPO, PPP
};

private int toTernary(int x) {
    // (This method will probably be in-lined ...)
    if (x < 0) return 0;
    else if (x == 0) return 1;
    else return 2;
}

private Category init(int i, int, j, int k) {
    int index = 9 * toTernary(i) + 3 * toTernary(j) + toTernary(k);
    return CATEGORIES[i];
}

Q2：您可以构建一个＆＃34;算法数组＆＃34;对象，由Category值的序数索引。

Answer 3

我可以指出你在switch语句的方向吗？ https://docs.oracle.com/javase/tutorial/java/nutsandbolts/switch.html

我已经多次使用它来摆脱麻烦的链条

如何更换if的长链

3 个答案: