Question

我一直在计划时间。一般说来,采用诸如PHP、ASP.net、Java、Java和他人等某些语言的方案。各种语文均须使用某一职位,如其他职位。如同价值=10时,............如果我审查我的守则,那么就找到条件。因此,我只想把他们减少到最低限度,而不会肯定。

其中一个点是使用一些微小的班级,但还是更多。

任务、任务、任务和类型:

if task =  add  then
   if cat = "animal" then
      if sec = "man" then
          if type = "male" then
                  do the following stuffs
          else
                  do the following stuffs
          end if
      elseif sec = "horse" then
          if type = "run"
                  do the following stuffs
          else
                  do the following stuffs
          end if
      elseif.......
      end if
   elseif cat = "plant" then
     if sec = "land" then
          if type="tree" then
                  do the following stuffs
          elseif type = "grass" then..
                  do the following stuffs
          elseif......
          end if
    elseif sec = "water" then
    ......
......

......

更正

那么,如何尽量减少这些缺陷和撰写一些有效的守则?

迟早告知,任务、编目、秘密和类型可能有一些价值。如果说的话,我会说话。

我的《守则》也与:

http://thedailywtf.com/Articles/Coding-Like-the-Tour-de-France.aspx

Answer 1

http://en.wikipedia.org/wiki/Polyfilism_in_object-Orient_programming” rel=“noreferer”>Poly吗?。

Answer 2

It s called Arrow Antipattern Some of the methods of dealing with it are described here: http://c2.com/cgi/wiki?ArrowAntiPattern

你认为的方法之一,是重新确定等级的编码,以区分诸如职能之类的职能。

if cat = "animal" then
  functionForAnimal();
elseif cat = "plant" then
 functionForPlant();
elseif...


function functionForAnimal() 
  if sec = "man" then
    functionForMan();
  elseif sec = "horse" then
    functionForHorse();
  elseif...

etc...

这把代码分成小块,易于维持,而且可能可再使用。

Answer 3

假设你总是进行平等比较,并比较所有四个领域,一个简单的数据驱动的方法是非常实际的。你们都需要做的是从(k、cat、sec、打字)到以下功能的地图:

handlers = {
    ( add ,  animal ,  man ,  male ): add_man_func,
    ( add ,  animal ,  horse ,  run ): run_horse_func,
    # ...
}

handler = handlers[(task, cat, sec, type)]
handler(some_args)

Answer 4

Poly吗? 如果你执行不同,任务在概念上是一样的,则可能有用。有时很难找到自然阶级结构,诸如 state patterns或strategy patterns 可能更为合适。

Answer 5

您描述了一个包含4个新参数的矩阵——task, cat, sec, category and one outding - stuff。因此,你们必须把它放在一边。

例如,XML地图和XPath query, i.e. String.Format(“task[@ Value={0}]/cat[@ Value={1}]/sec[@ Value={2}]/type[@ Value={3}]”,“add”、“animal”、“man”、“male”>,但这种办法指出了数据,而不是方法代表。

另一种方式:

void DoStuffA() { }
void DoStuffB() { }

var arr = new[]
{
    new { Task = "Add", Cat = "Animal", Sec = "Man", Type = "Male", Method = (Action)DoStuffA },
    new { Task = "Add", Cat = "Plant", Sec = "Land", Type = "Tree", Method = (Action)DoStuffB },
    // etc..
};

var action = arr.FirstOrDefault(i =>
     i.Task == "Add" &&
     i.Cat == "Animal" &&
     i.Type == "Male").Method;
action();

你们也可以不使用匿名成员,而是宣布一个班子,描述你在XML中的变数,将其从XML转至你的一些类别。

Answer 6

我认为,你的设计存在一些根本性的缺陷。我不知道你试图通过这一法典解决哪些问题,但这种守则在目标语言中非常少见。你的法典对我来说也似乎不合逻辑,因为,例如,变式的类型意味着第一次使用(正式)性别,然后意味着采取行动(连续)。你们是否注意到这一点?

无论如何,如果你确实使用 Java(或与班级做任何事),你需要的是抽象的。其次,把你可以的一切逻辑移到你的物体上——不以一个很强的例行做法处理。想这样做:我的对象知道如何做自己的事。

实际上,在这种情况下很难提供好的建议,我怀疑你的问题在你的申请中具有某些高层次的渊源,而这一判例法只是一种症状。在你看来,希望重新设计你的方案,采用面向目标的办法,也许会找到更好的解决办法。

如果你不肯定多变、抽象和其他业务目标的含义,那么你将需要就此读一下。

Answer 7

如果对每一种变量的选择是有限的,那么你甚至能够使用像环形田那样的手法操作。

例:

// give each field a byte so that each can have 256 possible values
#define TASK_ADD 0x01
#define TASK_SUB 0x02
...
#define CAT_ANIMAL 0x01
...
#define SEC_BOY 0x03
#define SEC_MAN 0x04
...
#define TYPE_FEMALE 0x01
#define TYPE_MALE 0x02
...

if ((task << 24 | cat << 16 | sec << 8 | type) == 0x01010402) {
  // do stuff
}

Answer 8

在有些地方,你需要与餐厅检查条件,以确保你做正确的事。如果你不希望对一个子点ram,你可以创造新的子。

Sub AddAnimalManMale()
    If task =  add  And cat =  animal  And sec =  man  And type =  male  Then
         perform the add animal man male action 
    End If
End Sub
Sub AddAnimalHorseRun()
    If task =  add  And cat =  animal  And sec =  horse  And type =  run  Then
         perform the add animal horse run action 
    End If
End Sub

之后,主次

...
Call AddAnimalManMale()
Call AddAnimalHorseRun()
...

Answer 9

打破法典是一切游戏。

历史上,你会这样做(而且已经是好的,或者至少是稳定的法典,而且所有这些法典仍然存在)。

你们现在在做这件事时,在巨大职能中独一无二,有许多评论。
分成几个定义明确、名称明确的职能
点名功能是复杂的 st脚石,如果你不断提到大结构,那么物体就成为发明的自然东西(不过,一旦你反对,就应该做一切,并重新使用以密码为对象的模式......)

承认这些模式的方式类似于给职能提供良好名称(加上你获得了自然有用的方法,可以赢得巨大的胜利)。

友情链接