Соглашения об именах Java
Соглашения об именовании Java – это рекомендации и рекомендации по написанию кода на Java. Они делают наш код последовательным и легким для чтения другими разработчиками Java.
- Автор записи
При написании кода на Java рекомендуется соблюдать определенные соглашения об именовании. Соглашения об именовании Java обеспечивают некоторую форму единообразия в вашем коде. Это облегчает чтение вашего кода другими разработчиками.
Хотя это не жесткие правила, лучше всего следовать этим правилам при написании кода.
1. Соглашения об Именовании Пакетов Java
- Имя пакета должно быть в маленьком футляре.
- В случае, если слов несколько, разделите их точкой.
- Префикс должен быть одним из доменных имен верхнего уровня, таких как com, edu, gov, mil, net, org, или одним из английских двухбуквенных кодов, идентифицирующих страны. (В США, Великобритании)
2. Соглашения об именовании классов и интерфейсов
- Имена классов и интерфейсов должны быть существительными.
- Они могут быть в смешанном регистре, но первая буква каждого внутреннего слова должна быть прописной. Это означает, что первая буква имени класса и интерфейса также должна быть прописной.
- Избегайте сокращений и аббревиатур.
3. Соглашение об именовании методов Java
- Методы должны быть глаголами, указывающими на функциональность этого конкретного метода.
- Они могут быть в смешанном случае.
- Первая буква должна быть в нижнем регистре, а каждое последующее слово должно содержать первую букву в верхнем регистре.
4. Соглашения об Именовании переменных Java
- Имена переменных не должны начинаться с символа подчеркивания (_) или знака доллара ( $ ).
- Начинайте имена переменных со строчной буквы, при этом каждое последующее слово должно содержать первую букву в верхнем регистре.
- Избегайте использования односимвольных имен переменных (i,j,k), за исключением временных одноразовых переменных.
- Имя переменной должно указывать на использование переменной.
5. Соглашения об именовании Констант
- Имя константы должно быть в верхнем регистре.
- В случае, если слов несколько, разделите их подчеркиванием (“_”).
Вывод
Это соглашения об именах, которые облегчат чтение вашего Java-кода. Однако нет необходимости использовать их при написании кода для производства, который будут читать другие люди, лучше всего использовать соглашения об именах Java.
Зачем ставить перед именами интерфейсов C# букву "I"
Никакой пользы не вижу. Дополнительный префикс просто загрязняет API.
Мое мышление совпадает с отклик Конрада относительно этого связанного вопрос; выбранный отвечать из которых в основном то, о чем я прошу здесь.
Я вижу два голоса, которые нужно закрыть, но я не уверен, что это действительно точная копия запроса об альтернативах. Если меня кто-то убедит, я проголосую за закрытие. (Пожалуйста, оставьте комментарий.)
Не дублируется и действительно хороший вопрос.
Не дубликат, но Джон Лимджап, кажется, думает иначе. Что я могу делать?
Это был не только Джон Лимджап. За это должны проголосовать 3 человека, он просто оказался третьим, кто это сделал.
@Simucal — Спасибо за разъяснения. Можно ли проголосовать, чтобы его открыть? Было бы полезно, если бы избиратели предоставили ссылку на предполагаемый дубликат.
Да, пользователи могут проголосовать за повторное открытие. Чтобы повторно открыть вопрос, нужно проголосовать 3 пользователя. В настоящее время за это проголосовал один пользователь, поэтому нужно еще два.
Для этого у вас также должен быть определенный уровень репутации, этот уровень должен быть в FAQ (3к репутации)
Ответы 18
Это позволяет легко идентифицировать его как интерфейс.
Я не вижу прямой ценности в различении интерфейсов и реализаций. Дальнейшая проработка может помочь.
Для меня реализация означает класс, который должен быть определен в соответствии с логической семантикой сущности / объекта, тогда как интерфейс означает поведение или контракт, который должен быть организован в соответствии с логическими группировками связанных поведений.
Либо так, либо добавить «Impl» в реализацию интерфейса (argh). У меня нет проблем с «Я», это самое простое и понятное название интерфейса.
Я не согласен с предложением «Impl» — это будет пустой тратой шума, как и префикс «I». Реализация должна быть названа с учетом ее реализации. Например, интерфейс «База данных» может быть реализован с помощью «RelationalDatabase» и «InMemoryDatabase».
Это соглашение, и вы не обязаны следовать ему, если оно вам не нравится.
Дело не в том, что мне это нравится. Я сомневаюсь в его ценности. Мне нравится придерживаться условностей не только ради того, чтобы следовать за стаей. Я хочу понять рациональное. Надеюсь, кто-нибудь сможет сформулировать эту рациональную идею помимо «он позволяет вам узнать свой интерфейс» (что IDE делает с красивыми значками).
Скорее всего, это делается для того, чтобы его можно было легко идентифицировать в intellisense, поскольку все интерфейсы будут сгруппированы вместе. Подобно тому, как я добавляю ко всем элементам пользовательского интерфейса префиксы btn, tb, lb. Когда срабатывает intellisense, все объединяется в одну простую группу.
Я считаю, что среда IDE может «группироваться» без использования соглашений об именах.
Мне также это нравится, потому что я могу прочитать это как «Я глагол-поведение», как в «ICanSave» или «IDoDoubleEntry» и т. д.
Возможно, стоит использовать приставку «Я».
да, можно было бы возразить, что подразумевается «Am» .. «IAmEnumerable», возможно, было бы яснее, а albiet — длиннее.
Я всегда нахожу, что названия моих интерфейсов немного напоминают лолоток. «ICanHasCheeseburger»
Разве это не противоречит соглашениям об именах C#? ICanSave должен быть ISaveble .
@Vapid, я думаю, это может быть в очень незначительной степени, поскольку глагольная фраза, конечно, не является прилагательным, но значение идентично. ISaveble или I[Am]Saveble означает то же, что и ICanSave . На самом деле, как я думаю об интерфейсах, это ближе к реальному значению. Интерфейсы — это способы объявить компилятору, что тип (класс или структура), реализует определенный набор поведения, то есть заставляет компилятор требовать, чтобы этот тип реализовывал поведение, определенное в интерфейсе. Итак, мне больше подходит глагольная фраза, заявляющая, что тип делает something.
@CharlesBretana Я просто подумал, потому что .NET называет свои интерфейсы как IClonable , IDisposable и IComparable , а не ICanClone , ICanDispose или ICanCompare .
@Vapid, да ты прав. «Стандартные» соглашения об именах гласят, что имена интерфейсов должны быть существительными, существительными фразами или (как дополнительный вариант) прилагательным. В нем не упоминаются глаголы или глагольные фразы. Я просто думаю, что конструкция глагольной фразы более четко выражает концепцию «реализации набора поведения».
Соглашения об именах предлагают вам что-то рассказать об объекте, прежде чем вы его используете. Соглашения об именах широко использовались в течение многих лет, начиная с утверждения Фортрана о том, что целочисленные значения были ограничены (если я правильно помню) именами переменных, такими как «i» и «j».
Нотация Венгрии подняла соглашения об именах на совершенно новый уродливый уровень, описывая тип переменной, был ли это указатель и т. д. У многих из нас, кто сталкивался с большим количеством кода с венгерской нотацией, развились нервные подергивания и словесные заикания.
Добавление к именам интерфейсов префикса I — это относительно легкий и безвредный способ идентификации этого объекта.
Какую пользу API дает определение типа и интерфейса? (Я понимаю разницу между интерфейсами и классами).
Это полная противоположность, соглашение об именах четко определяет интерфейс.
Например, если у вас есть:
Просто прочитав его, я могу с уверенностью предположить, что IPet и IMammal, вероятно, являются интерфейсами.
.NET CLR допускает наследование одного класса. Итак, если у меня есть базовый класс . я могу унаследовать от него только один класс. Давайте изменим интерфейс IPet на базовый класс . теперь наш пример выглядит следующим образом:
Я наследую от класса Pet и реализую интерфейс IMammal.
Если мы сделали то, что вы предлагаете, и удалили букву «I», то получим следующее:
От какого класса я наследую? Какой интерфейс я реализую? Это сбивает с толку, правда? (К вашему сведению . вы должны всегда ставить базовый класс первым, так что вы можете возразить с этим . но если вы утверждаете, что нужно удалить букву I из префиксов имен интерфейсов, я сомневаюсь, что вы тоже следуете этой практике)
Как видите, это соглашение об именах легко говорит мне много о моем объекте, и мне не нужно больше исследовать его. Я легко могу увидеть, что я наследую и что я реализую.
Это имеет смысл. Итак, в C# «расширяет и реализует» Java?
Я следую упомянутому вами соглашению «базовый класс всегда первым». Тем не менее, я не могу согласиться с вашим утверждением, что «соглашение об именах легко говорит мне многое о моем объекте». В данном случае различие между интерфейсом, абстрактным / конкретным классом, перечислением, распорками и т. д. Не имеет для меня значения на уровне API.
Почему бы нам не ставить перед абстрактными / конкретными типами префиксы «A» / «C», перечисления — «E», структуры — «S» и т. д.?
Я использую программную «среду», которая ТАК ужасна, что методы, атрибуты и объекты должны иметь префиксы «met, attr и obj» соответственно. objEmployee.metUpdate (objOther.attrId). Это очень читабельно и очень ясно, но мне это просто не нравится .
@Oscar — Я не могу сказать, саркастичен ты или идиотичен. В любом случае, я не думаю, что какой-либо здравомыслящий программист проголосовал бы за такое использование.
не похоже, что это его выбор
Это лучший ответ, но на самом деле причины таковы (по словам Кшиштофа Квалины), что «I» используется для historical reasons и (по словам Брэда Абрамса), что это clear recognition of the influence of COM (and Java) on the .NET Framework , и решение продвигать его вперед было вызвано тем, что так много ранних последователей платформы .NET Framework were already familiar with COM . (См. Этот ответ для получения более подробных цитат. stackoverflow.com/questions/222457/…)
Мне лично нравится, что все интерфейсы имеют префикс «I». Это позволяет мне сразу быстро распознавать интерфейс.
Довольно иронично, что java действительно все поняла. Интерфейсы больше не имеют префикса «I», но на самом деле это считается ПЛОХОЙ практикой. См. «Эффективная Java» Джошуа Блоха.
«Сначала базовый класс» — это не просто соглашение. Требуется компилятором: Base class ‘xyz’ must come before any interfaces . Это не означает, что я против использования «я» в качестве префикса. Помимо прочего, приятно иметь визуальный индикатор того, насколько интерфейс мой код или нет.
Визуальные «индикаторы» @Kyralessa — это то, что текстовые редакторы / IDE делают достаточно хорошо (например, окраска шрифтов, значки и т. д.)
То, на что это не отвечает, является более фундаментальным вопросом о том, почему вам нужно идентифицировать тип как интерфейс, равно как вам не нужно определять, является ли он классом или структурой . или является ли он абстрактным или нет . или содержит ли он члены экземпляра или только статические . Я думаю, что да, но я не уверен, какой лучший ответ — почему .
На самом деле я считаю полезным избегать конфликтов имен, я мог бы, например, создать конкретный класс с именем Fred, который реализует IFred
Конфликтов в именах можно избежать за счет использования значимых / полезных имен. Например. Фред расширяет Person, реализует возможности Living, Breathing и другие. Без дополнительного контекста я не могу сказать наверняка, но если Фред является объектом предметной области / модели, наличие интерфейса для него, вероятно, излишне.
Я считаю, что соглашение об именах IInterface глупо. Это пример венгерской нотации, и я присоединяюсь к школе мысли, которая презирает венгерскую нотацию. Если у вас есть интерфейс только с одной реализацией с таким же именем, подумайте о том, что это запах кода.
Тем не менее, я все еще использую его, потому что в этом случае IInterface рекомендован Microsoft, и «стандарт лучше, чем лучше».
Я тоже никогда не был поклонником венгерского языка, но недавно я наткнулся на эту старую статью Джоэла, в которой объясняется ее происхождение и то, как ее часто неправильно понимали — по крайней мере, теперь я вижу причину этого! joelonsoftware.com/articles/Wrong.html
Я всегда считал забавным использовать глаголы для поведенческих интерфейсов. Это отход от соглашения об именовании классов с использованием существительных, но позволяет классу «говорить» со своим поведением.
Это плохо работает для структурных интерфейсов, таких как интерфейсы WCF, но нам не нужно постоянно получать удовольствие.
чтобы ответить на ваш вопрос, подумайте о I как о «приспособлении». Итак .
этот класс обслуживания наследуется от Dog и реализует IDataService
Я все еще не отвечаю на ваш вопрос, но I полезен, потому что вы получаете коллизии имен между пространством имен, классом и интерфейсом.
так что мы получаем
Я думаю, что на самом деле это условность здравомыслия.
+1 — вообще говоря, я думаю, что соглашения об именах указывают на слабость в языке разработки (и это, вероятно, так и здесь), но, тем не менее, важно иметь возможность избежать этих столкновений, когда вы хотите использовать внедрение зависимостей и имитировать объекты-участники . На самом деле нет альтернативы соглашению об именах при создании интерфейсов для объектов домена.
/ shrug Я тоже использую его для служб WCF. У меня есть IServeData и ICanMakePayments для двух моих услуг.
@JeffSternal Я думаю, вы могли бы применить антипаттерн «каждый объект должен иметь интерфейс». Вероятно, вам не следует создавать интерфейсы для объектов домена; они часто являются ожидаемой частью вашего общедоступного API.
Это просто соглашение об именах, поэтому все будут знать, интерфейс это или что-то еще, это не обязательно ни для компилятора, ни для IDE, но все интерфейсы, которые я видел за всю свою жизнь, начинаются с буквы I
Во-первых, я считаю, что префикс с I, а затем описание неверен, потому что это означает, что реализации могут иметь более короткое имя. IList (intf) -> Список. Это анти-шаблон, поскольку все мы знаем, что при создании следует использовать intf и, вероятно, только конкретные типы. Не огорчай меня, это обобщение, но исходная посылка возникает редко. Название реализации должно описывать, как она реализует intf или что она делает. Подумайте intf List, LinkedList, который реализует List с использованием связанного списка. Кого волнует, длиннее ли это, поскольку мы должны использовать List большую часть времени. Если у нас есть класс, реализующий много intf, мы, вероятно, не должны включать все intf, поскольку тени являются реальной целью класса. В случае, если что-то удалено без intf, имеет смысл. Например, люди зовут меня по имени, а не по имени, а не по имени, брат или сестра, разработчик и т. д. Использование моего имени — это лучшее, наиболее описательное имя. Я полагаю, что если класс подразумевается как простой intf, тогда назовите его Default Intf, что делает его единственной реализацией Intf по умолчанию. Имена классов должны быть понятны человеку и должны быть почти короткими фразами, описывающими их назначение. Коды префиксов и т. д. Не очень хороши, поскольку мы общаемся словами, а не кодами. Компьютеры не знают, какие классы называются, поэтому остается то, что мы называем вещи так, чтобы имена помогали нам и нашим коллегам.
Условие «я» кажется старым условием, которое сегодня не актуально. Текущий редактор кода дает много информации о типе, который вы используете, поэтому утверждать, что интерфейс легче идентифицировать, все равно, что просить пространство имен иметь префикс «N», потому что вы хотите быть уверены, что не перепутаете его с конкретный класс (префикс с «C»?).
Соглашение не означает, что это хорошее соглашение. Иногда это просто потому, что люди используют это .
Возьмем, к примеру, генератор документации C#: его это не волнует . если ваш интерфейс не имеет префикса «I», вы все равно увидите свой интерфейс в интерфейсной части вашей документации. Вы действительно думаете, что наличие префикса «I» для всех ваших интерфейсов в разделе интерфейса вашей документации является важной информацией и поможет вам лучше идентифицировать интерфейсы?
Почему это не функция синтаксической подсветки вместо венгерской нотации? Почему в среде IDE не выделены курсивом идентификаторы, относящиеся к интерфейсам, если так важно различать классы и интерфейсы. Я ненавижу ставить ««или» м» перед полями, «C» перед классами и т. д. Что еще хуже, это побуждает программистов писать действительно плохие API, такие как:
вместо более разумного:
В эту ловушку попадали даже авторы общих классов .NET. Имя класса НИКОГДА не должно быть именем интерфейса с удаленной буквой «I». Имя класса всегда должно указывать пользователю, чем класс отличается от других возможных реализаций интерфейса (ов). Я голосую за то, чтобы отбросить глупое «я» только по этой причине.
Кроме того, когда я использую intellisense, я хочу сгруппировать вещи по функциональным областям, а не по классам или интерфейсам. Я никогда не думаю: «Мне нужен интерфейс, а не класс». Я всегда думаю: «Мне нужно что-то, что делает X».
Я рад, что я не единственный, кто это видит. Похоже, я в меньшинстве. Спустя 4 года я все еще поражаюсь тому, сколько читателей клянутся, что «это позволяет легко идентифицировать интерфейс», и совершенно не понимают сути.
Это действительно хороший момент при разработке интерфейса с учетом расширяемости, но другой вариант использования абстрагирования интерфейсов (C# и Java) предназначен исключительно для выгоды разделения, позволяющей имитировать зависимости, где не было другой конкретной реализации интерфейса. явно «разработан для». Так что MyReallySpecificBusinessComponent и IMyReallySpecificBusinessComponent подойдут. Но точно не List .
Если вы рассмотрите два «афоризма передового опыта»
между ними существует конфликт. Возникает вопрос: когда четкость становится шумом?
Для меня более шумно (но одинаково понятно) писать Person person = new PersonImpl() , чем IPerson person = new Person() .
Или еще лучше, Человек p = new TallPerson (); но в моем случае Person вряд ли будет интерфейсом. Вместо этого это базовый тип, который расширяет TallPerson, или абстрактный тип. В любом случае «интерфейс» Person подразумевается его общедоступным API. Я презираю FooImpl () так же сильно, как IFoo.
Мне кажется, что это традиционная конвенция от венгерской нотации. Рекомендации по именованию интерфейсов говорит: «Приставьте имена интерфейсов к букве I, чтобы указать, что тип является интерфейсом». Рекомендации по проектированию каркаса также говорит: «DO имена интерфейсов префикса с буквой I, чтобы указать, что тип является интерфейсом».
Это просто соглашение о кодировании, поэтому трудно определить, хорошо или плохо. Главное — последовательность.
Со всеми аргументами о соглашениях об именах и присвоении собственных имен переменным и методам, которые фактически описывают то, что они делают . почему бы просто не назвать свои интерфейсы (например, PetInterface, PlayerInterface и т. д.) И покончить с префиксом «I» все все вместе. Итак, вам нужно ввести дополнительные 9 букв, по крайней мере, «I» удалено, и мы знаем, что это не класс, потому что он говорит «Интерфейс».
Это ужасная идея. Почему бы не назвать свои классы «DogClass»? Если бы кто-то сделал это в моей кодовой базе, я бы очень расстроился. Есть стандарт; используй это.
TL; DR — Извлечение interface IFoo из class Foo является обычным делом при развязке SOLID, особенно для целей модульного тестирования
Для меня двойное соглашение класса Foo , реализующего интерфейс IFoo (особенно если оба находятся в одной сборке), выражает конкретное намерение, которое:
- Связывание зависимости с Foo всегда должно быть косвенным, через соответствующий интерфейс IFoo (и, вероятно, будет внедрено через контейнер IoC)
- Первоначальный дизайн IFoo — это проприетарный, не подлежащий повторному использованию интерфейс, специально позволяющий классам, зависящим от Foo , имитировать эту зависимость во время модульного тестирования.
- Помимо вышеизложенного, читателю не нужно делать вывод о каких-либо дополнительных интеллектуальных способах разработки интерфейса IFoo .
- И наоборот, если в дальнейшем потребуются несколько конкретных классов реализации IFoo , этот надлежащий дизайн сегрегации интерфейса необходимо будет модернизировать в иерархии.
Обоснование
Чтобы иметь возможность создавать макеты или заглушки для класса, широко распространенной передовой практикой в модульном тестировании является разделение зависимостей между классами только через интерфейсы. Это разделение интерфейса также будет выполнено для классов, которые в противном случае имели бы никогда не требовал полиморфизма (т.е. существовала бы только одна такая реализация, если бы не необходимость в модульном тестировании).
Как следствие, рефакторинг и повторное использование этих интерфейсов (например, Принцип разделения интерфейса SOLID ) не часто применяется к таким «имитируемым» интерфейсам — часто существует корреляция 1: 1 между общедоступными методами, свойствами и событиями «имитируемого» класса. ( Foo ) и его развязанный интерфейс IFoo (аналогичный автоматические интерфейсы в VB эпохи COM).
Такие инструменты, как ПРОТИВ и Resharper, могут сделать извлечение таких общедоступных символов из класса в отдельный интерфейс тривиальным занятием в качестве запоздалой мысли.
Кроме того, если учесть, что фреймворки Mocking, такие как Moq, допускают определение реализаций интерфейса на лету, нам не нужно тратить усилия, называя конкретный тестовый класс двойной реализации.
Необходимость различать интерфейс и класс фактически указывает на недостаток дизайна. В хорошо спроектированном приложении всегда будет ясно. Подкласс всегда должен быть специализацией, а классы могут быть специализированы только по одному предмету, никогда больше.
У класса должна быть единственная причина для существования. Никогда не требуется помещать второстепенные роли в базовый класс. Например.:
Первый — это файл конфигурации, специализирующийся на Xml, второй — на Yaml. Они тоже одноразовые, но это не имеет большого значения. Вы не создали эти два класса из-за разных процессов утилизации.
Ограничьте это с помощью:
Это покажет вам, что основная цель XmlConfigurationFile — это одноразовый. То, что вы можете использовать его как способ представления файлов конфигурации, приятно, но вторично.
Проблема начинается, когда вы создаете классы, у которых есть несколько причин для существования:
Даже если бы XmlConfigurationFile и YamlConfigurationFile были интерфейсами, это все равно указывает на плохой дизайн. Как ваш файл конфигурации может быть одновременно Xml и Yaml?
Если вы прочитаете приведенные примеры (здесь и в других местах), людям всегда будет сложно найти хороший пример того, когда префикс I имеет значение. Один из ответов здесь:
Вот так этот класс будет выглядеть в приложении про домашних животных. Основная цель собаки — быть специализированным домашним животным, которое может делать вещи, связанные с домашними животными, а не то, что это млекопитающее.
Вот как один и тот же класс будет выглядеть в приложении о классификации животных. Приятно знать, что собака — это домашнее животное, но ее главная цель — быть специализированным млекопитающим, которое может делать вещи, связанные с млекопитающими.
Я думаю, что ваши классы должны рассказать вам правильную историю об архитектуре и предметной области вашего приложения. Требование к интерфейсу начинаться с префикса «I» является техническим требованием и не поможет вам лучше рассказать историю вашего приложения.
Как только вы начнете писать небольшие, специализированные, одноцелевые классы, необходимость знать, реализует он или расширяется, автоматически исчезнет.
Это должен быть утвержденный ответ. Хорошо написано и информативно. Спасибо.
Как придумать более четкие имена интерфейсов?
Я видел в приложении, где у него были интерфейсы, такие как:
не должны ли они быть?:
лично я склоняюсь к тому, чтобы просто сделать их:
потому что это не ISomething уже подразумевает, что у него есть это something ?
Что касается последнего, я должен сделать это ?
Я думаю, что с помощью I + (Has/Have/Include/Exist, etc) + Name делает имена интерфейса более запутанными.
любой идеи о том, как придумать лучшие имена интерфейса, которые не чувствуют себя неловко, к месту и получают смысл?
7 ответов
некоторые из этих имен (содержимое, значение и т. д.) расплывчаты и мало что делают для описания содержимого/поведения элемента. В общем, имена должны быть как можно более конкретными и отличными — IScriptParameter может быть более описательным, чем IValue. По мере роста вашего проекта более описательные имена сделают ваши типы намного проще различать (если вы не будете осторожны, вы можете в конечном итоге получить IValue и INumber и IAmount для обработки вариаций «значений»!)
Если ваш интерфейс (напр. IMesh) означает «предоставляет свойства сетки», тогда IMesh — это совершенно прекрасное имя-оно описывает тот факт, что вы можете относиться к объекту как к сетке.
Если ваш интерфейс используется для применения действия (например. для отображения объекта в виде сетки, или чтобы применить преобразование к объекту), а затем рассмотреть, используя глагол/прилагательное, а не существительное именования (например IRenderable, ITransformable) — это стандартный шаблон .чистый (интерфейс IEnumerable (глагол/прилагательное), а не интерфейс ICollection (существительное), для пример)
для меня «IHasMesh «звучит больше как IMeshContainer — т. е. это объект, который содержит сетку, и интерфейс позволяет мне»получить сетку». Таким образом, это не позволит мне действовать или запрашивать данные внутри сетки, а просто получить весь объект сетки через интерфейс.
поэтому я бы использовал:
- ITransformable если объект может быть преобразован через интерфейс
- ITransform если объект можно использовать напрямую, как если бы это преобразование
- IHasTransform/ITransformContainer / ITransformProvider если объект является контейнер который можно запросить для извлечения объекта преобразования
лично мне нравится IHas+Word, потому что имя интерфейса описывает свойство классов, которые их реализуют. Например:
С другой стороны,
заставляет меня задуматься, если lolcats есть чизбургеры или ARE чизбургеры (это традиционный глагол, используемый при интерпретации наследования).
первое, что вы должны понять, это то, что «я» в первых именах не относится к местоимению «я», а скорее следует стандарту именования, который интерфейсы начинаются с заглавной буквы «Я»
в этом смысле интерфейсы фактически называются «HasContent», «HasValue» и т. д., Поэтому не меняйте его на «HaveContent» и «HaveValue», так как это было бы так же неудобно.
С учетом сказанного, я не могу точно понять, для чего используются эти интерфейсы. — интерфейс (по определению) предназначен для принудительного выполнения условия для всех классов, которые его реализуют, и я не уверен, что эти интерфейсы применяют-что все классы имеют функцию HasContent() ?
Я думаю, что вы должны вместо этого сосредоточиться на интерфейсах, имеющих is a отношения. При объявлении класса, реализующего интерфейс IList , вы не подразумеваете, что ваш класс и список, но скорее, что ваш класс это список.
так, например, один из них IHasGeometry . ну, это дает мне возможность проверить, имеет ли он геометрию, но я бы реально хотел иметь дело только с цифрами, которые are геометрические фигуры, поэтому я бы создал интерфейс с именем IGeometricFigure вместо этого, таким образом, ограничивая его использование для всего, что работает на геометрических фигурах.
Я согласен, что имена звучат неудобно, но я думаю, что это больше, потому что эти интерфейсы используются для неудобного цель, а не потому, что они неправильно названы.
ваш первоначальный список имен интерфейсов совсем верно. Имя интерфейса должно описывать контракт. Например, это один интерфейс, с которым я недавно столкнулся, который мне очень понравился:
идеально! Имя говорит само за себя. «Я» относится к тому, что это интерфейс, а остальное описывает, что контракт будет выполнять.
если интерфейс был назван IEmptyValue , это означало бы, что интерфейс гарантирует, что разработчик является пустым значением. Это не — у него есть способность определить является ли значение пустым.
(вероятно) класс не будет называться DeterminesEmptyValue . Но может быть тысяча классов, которые все имеют возможность определить, являются ли различные типы значений пустыми, и этот интерфейс позволяет им всем вызываться общим способом.
интерфейс должен четко описывать конкретную характеристику классов, которые реализуют его. В случае IContent — у реализаторов есть содержание, или реализаторы ARE контент?
мне нравится думать, что ISomething означает, что is что-то, как в игре роли чего-то, а не то, что оно «имеет» или «включает» что-то. Итак, IFather «означает» я играю роль отца, или я отец’. IDispatcher «означает» я играю роль диспетчера » или «я диспетчер’ и т. д.
некоторые люди любят называть интерфейсы для ответа на вопрос-что мне делать?’: IListenForEvents , ILogExceptions . как в этом посте
интерфейсы используются для многих целей, с различными запутанными соглашениями об именах. Прежде чем беспокоиться об именах, вероятно, хорошо сначала решить, как отделить функциональность. Коллекции Microsoft, к сожалению, имеют слишком мало отдельных интерфейсов, самые большие ommissions-IReadableList и IAppendable, оба из которых могут быть унаследованы IList, но поддерживают поддержку контравариации и ковариации [так что можно передать IList (Cat) в код, ожидающий IReadableList (животного) или IAppendable (из SiameseCat)]. С другой стороны, также можно разделить вещи слишком мелко, поэтому любой полезный класс должен реализовать десятки интерфейсов.
Не зная, какие типы функций использовались в приложении и интерфейсах, трудно сказать, были ли они разработаны с хорошим уровнем детализации. Похоже, они слишком тонко разделены, но я не могу точно сказать. Как только функциональность сгруппирована соответствующим образом, тогда имеет смысл беспокоиться о имя.
«Я «не означает»меня». Это просто означает интерфейс.
но у Microsoft есть свои собственные директивы для именования интерфейсов.
имена должны отличаться только префикс буквы I в имени интерфейса.