Что лучше и почему? (С точки зрения дизайна интерфейса):
а) иметь два Show()
и Hide()
функции
б) иметь одну SetVisible(bool visible)
функцию
РЕДАКТИРОВАТЬ: Например, некоторые объекты имеют состояние видимости, и эта функция используется для его изменения.
в) иметь все три Show()
, Hide()
, SetVisible(bool visible)
функции
java
c++
interfaces
user3123061
источник
источник
Ответы:
Я предпочитаю
SetVisible(bool visible)
, потому что это позволяет мне писать код клиента так:вместо того, чтобы писать
SetVisible
Подход может обеспечить более легкое осуществление. Например, если конкретный конкретный класс просто делегирует метод его составным классам, этоSetVisible
означает, что для реализации потребуется на один метод меньше.источник
MyObject.Visible = false;
мне кажется еще более интуитивным, чемMyObject.SetVisible(false);
SetVisible()
не предлагает (для меня), что вы на самом деле что-то показывает. Это больше похоже на то, что вы устанавливаете свойство видимости объекта, возможно, оставляя его на усмотрение соответствующего методаRefresh()
илиRedisplay()
метода, чтобы проверить значение этого свойства, чтобы определить, должен ли объект отображаться или скрываться.setVisible(true)
Будет запущен процесс, при котором объект будет прорисован, когда система будет в следующий раз бездействующей, если не раньше. Я ожидаю, что этоrefresh
может быть полезно для ускорения отображения объекта, но что объект в конечном итоге будет нарисован независимо (если, например, его видимость не была установлена доfalse
того, как это произошло).Я не согласен со всеми плакатами, предлагающими несколько функций для выполнения одной и той же вещи - это хорошо. Хотя три функции вместо одного может показаться не так много наворотов, помните , что ваш класс, скорее всего, в конечном итоге с большим количеством таких функций (например
setEnabled
,enable
,disable
) и , таким образом , этот подход будет в конечном итоге с гораздо большим интерфейсом класса. Более того, вполне вероятно, что в результате вы получите кучу схожих по звучанию функций / свойств / чего угодно в вашем классе, и умножение функций еще больше затеняет, какой из них идет с чем.В языках, которые поддерживают свойства, они должны быть предпочтительнее, но, поскольку ни Java, ни C ++ не поддерживают, я думаю, это спорный вопрос.
Я думаю, что
setVisible()
следует отдавать предпочтение по этим причинам:setVisible(false)
вызов вы звоните,setVisible(true)
тогда как противоположностьhide()
легко может бытьreveal()
.setVisible(wantToSee)
а не использоватьif
оператор.setX()
формат обобщается, поэтому вы можете иметь набор согласованных функций, в то время как подход с использованием глаголов порождает множество функций, которые может быть трудно найти, если вы не знаете, что ищете. Согласованность API-интерфейсов значительно облегчает их изучение и запоминание.источник
Это зависит от того, что значит показать и скрыть в контексте. Сначала вы хотите выяснить, какой из них является вашим «основным путем», и сосредоточиться на разработке этого:
setVisible(bool)
show()
иhide()
Итак, теперь, когда вы закодировали его «золотой стандарт», вам нужно выяснить, стоит ли добавлять тонкие удобные методы в другом стиле, чтобы облегчить жизнь тому, кто будет использовать ваш объект.
setVisible(bool)
setVisible(a==b)
)show()
иhide()
onSuccess(widget.show)
)TLDR: выясните , какой из них наиболее важен, реализуйте его, а затем спросите себя, стоит ли добавлять другой стиль в качестве тонких удобных методов.
источник
Я бы сказал "все три".
Show()
и,Hide()
как правило, легче впасть, чемSetVisible(true)
иSetVisible(false)
. Однако, когда вы хотите установить видимость логически, лучше иметь метод, который принимает,bool
а не создаетif
вокруг негоbool
.Вы можете поддерживать все три, не дублируя логику и минимальный шаблон:
В качестве альтернативы, если вещи, которые вы упаковываете, имеют более
SetVisible
-рочный API:источник
System.Windows.Forms.Timer
. Лично я считаю, что это сбивает с толку. Когда я вижу и то,Show
и другоеSetVisible
, я склоняюсь к мысли, есть ли какое-то важное различие между этими двумя функциями.Я предпочитаю show () и hide (), фактически каждый метод, который получает один логический тип, может быть изменен на два метода, которые лучше выражают намерение API. Например, Роберт Мартин в чистом коде рекомендует отдавать предпочтение методам без аргументов по сравнению с методами с одним аргументом.
Другим важным аргументом для меня является удобочитаемость, на мой взгляд, хороший код можно читать как прозу, его действительно странную прозу, например, «main_window setVisible false» вместо «main_window hide», вы пишете или говорите так обычно? построение языка в программном обеспечении, когда вполне возможно использовать более естественный язык?
источник
it.setVisible(false); it.setVisible(true);
не должна влиять на видимость родительского элемента управления и не должна влиять на Z-порядок или местоположение элемента управления. В отличие отhide(); show()
; вполне может заставить родителя элемента управления быть видимым, переместить его над другими элементами управления и ограничить его положение в каком-либо месте, которое можно увидеть. В некоторых случаях полезно иметь возможность убедиться, что что-то действительно видно (как в случае с вышеупомянутымshow()
, но в других случаях полезно изменить флаг видимости, не меняя ничего другого.Я верю, что чем более выразительный метод, тем более читабельным и, следовательно, поддерживаемым будет код. Рассмотрим следующие два случая:
Дело 1:
Случай 2:
В первом случае ясно, что делает функция setVisible, но если вы хотите прочитать ее, вы скажете:
Хотя более информативно сказать:
который изменит функцию «Случай 1» на следующее:
он производит больше кода, но более читабелен.
Во втором случае есть очевидный недостаток: вы уже знаете, что хотите показать панель, так почему бы не использовать функцию «Показать»?
Я не говорю, что использование «setVisible» является абсолютно неправильным, но это сбивает с толку, когда вы пытаетесь прочитать код, не написанный вами с течением времени, и это не соответствует правилу «Функция должна выполнять только одну операцию».
источник
show customer panel iff the user/customer is enabled
. Я согласен с тем, что может быть множество более сложных условий, которые не так легко прочитать, как ваш пример, однако в этих случаях я бы разбил эти условия на разные строки.Я полагаю, что
Hide()
/Show()
альтернатива привлекательна, потому что легче понять, что происходит, чем когда с нейSetVisible(true)
, хотя наличие единственной функции предпочтительнее, потому что она избегает множества условий.Если это так, то я предлагаю использовать перечисление в качестве входных данных для
SetVisible
, так что вы получите либоSetVisible(Visibility.Visible)
илиSetVisible(Visibility.Hidden)
. У вас есть одна функция, вы можете мгновенно прочитать, какие действия предпринимаются.Используя соглашения об именах Java, вы могли бы иметь
setVisible(Visibility.VISIBLE)
илиsetVisible(Visibility.HIDDEN)
.источник
Я согласен с ответом Дариена, но хотел добавить точку зрения с точки зрения программистов на C #.
Когда я вижу код, который говорит «setXXX», я читаю это, чтобы сказать, что он устанавливает значение для чего-либо, я не ожидаю, что это будет иметь побочные эффекты в этом, кроме установки этого значения, и я ожидаю, что это будет идемпотентным (т.е. я могу продолжать устанавливать его с тем же значением, и это нормально). Это скорее как доступ к полю. Как правило, я бы также ожидал увидеть метод getXXX вместе с setXXX.
Я не знаю, ожидаете ли вы этого в Java и C ++, но это то, что я ожидал бы в C #, хотя в C # есть сокращение для этого, называемое Properties. И вот несколько хороших советов о том, как использовать свойства ( http://msdn.microsoft.com/en-us/library/ms182181.aspx ).
Учитывая это представление, интерфейс, который я бы выбрал, зависит исключительно от наличия побочных эффектов (кроме изменения значения этого поля):
Если выполнение действия имеет побочные эффекты, например, оно показывает диалоговое окно, тогда я бы выбрал «Показать ()» и «Скрыть ()».
Если у него нет побочных эффектов, скажем, я устанавливаю видимость «виджета», а что-то еще отображает этот виджет в зависимости от его состояния, тогда я бы использовал setVisibility или setIsVisible. (Я бы не назвал это SetVisible).
В C # (не уверен в Java) довольно распространено использование шаблона наблюдателя, в котором инфраструктура пользовательского интерфейса будет прослушивать изменения объектов и автоматически повторно отображать пользовательский интерфейс при изменении свойства, такого как Visibility. Это означает, что установка значения путем вызова setIsVisible выглядит так, как будто у него есть побочные эффекты, но в моем определении это не так. Контракт виджета выполняется путем установки значения его поля, представляющего «IsVisible».
Другими словами, я могу переключать видимость метки в форме перед ее отображением. Т.е. label.getIsVisible == true, но форма не отображается.
Я не могу вызывать Hide (), когда форма не отображается.
источник
getXXX()
иsetXXX()
методы как способ получить доступ к полю без побочных эффектов звучит как Java, а не как C #. Это способ, которым вы должны сделать это в Java, потому что у него нет свойств. Если бы я видел такой код в C #, я бы предположил, что он написан Java-разработчиком, который еще не узнал о свойствах в C #.SetVisibility
.getXX
вызова есть соответствующийsetXX
метод, то онsetYY
не должен влиять на него, но это может повлиять наgetZZ
вызов, у которого нетsetZZ
метода.Я бы предложил немного измененный интерфейс:
Лучшие имена
Эти имена методов помогают разработчику решить, какой метод использовать, основываясь на том, что необходимо сделать. Принимая во внимание,
SetVisible(bool visible)
что разработчик может сбить с толку, поскольку он передает то же семантическое значение, чтоShow()
иHide()
,Toggle()
подразумевает существование условия, определяющего действие. Таким образом, становится понятным для разработчика, когда использовать каждый метод.Уменьшенная избыточность кода
Преимущество наличия нескольких методов в вашем интерфейсе состоит в том, что это упрощает вызывающий код. Вы могли бы просто выставить
Show()
иHide()
, но:SetVisible()
приватный метод, чтобы выполнить реальную работу за кулисами (или написать избыточный код дляShow()
иHide()
).SetVisible()
(илиToggle()
) уже делает, чтобы избежать раздувания кода (я ненавижу избыточный код). Таким образом, дублируется метод, который, вероятно, уже существует как частный метод в реализации.источник
Я бы предложил использовать,
SetVisible(bool)
если таковые имеются, только если переключение видимости дважды (показать и повторно скрыть, или скрыть и повторно показать) оставило бы вещи по существу в том же состоянии, что и до выполнения операции (это хорошо, если показывать и повторно скрывать что-то или наоборот оставляет объекты нуждающимися в перерисовке, при условии, что это может произойти «автоматически»). Если сокрытие и показ объекта не будет иметь никакого эффекта, кроме изменения одного бита состояния, тогда для внешнего кода будет иметь смысл иметь некоторые методы, которые принимают параметр видимости, и написание такого кода будет облегченоSetVisible
.Если скрытие и повторное отображение объекта может иметь побочные эффекты, такие как изменение порядка Z, такие действия, скорее всего, следует выполнять отдельными методами. В таких случаях полезность внешних методов, которые принимают параметр «видимости», будет ограничена, и поэтому будет мало преимуществ для их облегчения. Кроме того,
SetVisible
метод (ошибочно) предполагает, что изменения видимости объектов могут быть выполнены без побочных эффектов.источник