Elettracompany.com

Компьютерный справочник
2 просмотров
Рейтинг статьи
1 звезда2 звезды3 звезды4 звезды5 звезд
Загрузка...

Java пространство имен

Как объявить пространство имен в JavaScript?

Как создать пространство имен в JavaScript, чтобы мои объекты и функции не перезаписывались другими одноименными объектами и функциями? Я использовал следующее:

есть ли более элегантный и лаконичный способ сделать это?

27 ответов

Мне нравится это:

вот их пример, показывающий, как объявить частные и публичные свойства и функции. Все делается как самоисполняющаяся анонимная функция.

поэтому, если вы хотите получить доступ к одному из общественных членов, вы просто пойдете skillet.fry() или skillet.ingredients .

что действительно здорово, так это то, что теперь вы можете расширить пространство имен, используя то же самое синтаксис.

третий undefined аргумент

третий undefined аргумент является источником переменной value undefined . Я не уверен, что это все еще актуально сегодня, но при работе со старыми браузерами / стандартами JavaScript (ecmascript 5, javascript undefined доступен для записи, поэтому любой может переписать его значение. Третий аргумент (если не передано значение) создает переменную с именем undefined что область действия пространства имен / функции. Поскольку значение не было передано при создании пространства имен, по умолчанию используется значение undefined .

другой способ сделать это, который я считаю немного менее ограничительным, чем литеральная форма объекта, заключается в следующем:

выше очень похож на шаблон модуля и нравится вам это или нет, это позволяет выставлять все ваши функции как общедоступные, избегая при этом жесткой структуры объектного литерала.

есть ли более элегантный и лаконичный способ сделать это?

Я обычно строю его в закрытии:

мой стиль за эти годы имел тонкие изменения с момента написания этого, и теперь я обнаружил, что пишу закрытие так:

таким образом, я нахожу публичный API и реализацию более понятными. Подумайте о инструкции return как о публичном интерфейсе к реализации.

поскольку вы можете писать разные файлы JavaScript и позже комбинировать или не комбинировать их в приложении, каждый должен иметь возможность восстанавливать или создавать объект пространства имен, не повреждая работу других файлов.

один файл может использовать пространство имен namespace.namespace1 :

другой файл может захотеть использовать пространство имен namespace.namespace2 :

эти два файла могут жить вместе или порознь, не сталкиваясь.

вот как это делает Стоян Стефанов в своем Шаблоны JavaScript книга, которую я нашел очень хорошей (она также показывает, как он делает комментарии, которые позволяют автоматически создавать документацию API, и как добавить метод к прототипу пользовательского объекта):

Я использую такой подход:

внешний код может быть:

это продолжение ссылки user106826 на пространство имен.js. Кажется, проект переместился в GitHub. Сейчас smith / namespacedotjs.

Я использую этот простой помощник JavaScript для моего крошечного проекта, и до сих пор он кажется легким, но достаточно универсальным для обработки пространства имен и загрузка модулей/классов. Было бы здорово, если бы это позволило мне импортировать пакет в пространство имен по моему выбору, а не только в глобальное пространство имен. вздох, но это к делу не относится.

Он позволяет объявить пространство имен, а затем определить объекты / модули в этом пространстве имен:

другой вариант-объявить пространство имен и его содержимое сразу:

дополнительные примеры использования, рассмотрим на примере.файл JS в источник.

вы можете дополнительно объявить local переменная same , как self и назначить local.onTimeout если вы хотите, чтобы быть частным.

вы можете объявить простую функцию для предоставления пространств имен.

Я создал пространство имен который вдохновлен модулями Erlang. Это очень функциональный подход, но именно так я пишу свой код JavaScript в эти дни.

Он дает закрытию глобальное пространство имен и предоставляет определенные функции набора в этом закрытии.

Если вам нужна частная область:

else если вы никогда не будете использовать частную область:

Я использую следующий синтаксис для пространств имен.

шаблон модуля первоначально был определен как способ обеспечения как частной, так и публичной инкапсуляции для классов в обычной программной инженерии.

при работе с шаблоном модуля может оказаться полезным определить простой шаблон, который мы используем для начала работы с ним. Вот один, который охватывает интервал имен, общедоступные и частные переменные.

в JavaScript шаблон модуля используется для дальнейшей эмуляции концепции классов таким образом, что мы возможность включать как публичные / частные методы, так и переменные внутри одного объекта, тем самым экранируя определенные части от глобальной области. Это приводит к уменьшению вероятности конфликта имен наших функций с другими функциями, определенными в дополнительных сценариях на странице.

преимущества

почему шаблон модуля является хорошим выбором? Для начала, это намного чище для разработчиков, исходящих из объектно-ориентированного фона, чем идея истинной инкапсуляции, по крайней мере, с точки зрения JavaScript.

во-вторых, он поддерживает частные данные-таким образом, в шаблоне модуля публичные части нашего кода могут касаться частных частей, однако внешний мир не может касаться частных частей класса.

недостатки

недостатками шаблона модуля является то, что, поскольку мы получаем доступ к публичным и частным членам по-разному, когда мы хотим изменить видимость, мы на самом деле нужно внести изменения в каждое место, где был использован член.

мы также не можем получить доступ к частным членам в методах, которые добавляются к объекту в более поздний момент. Тем не менее, во многих случаях шаблон модуля по-прежнему весьма полезен и при правильном использовании, безусловно, имеет потенциал для улучшения структуры нашего приложения.

Раскрывая Картина Модуля

теперь, когда мы немного знакомы с модулем pattern, давайте взглянем на немного улучшенную версию-показательный модульный шаблон Кристиана Хейльмана.

показательный шаблон модуля произошел, когда Хайльман был разочарован тем фактом, что ему пришлось повторить имя основного объекта, когда мы хотели вызвать один общедоступный метод из другого или получить доступ к общедоступным переменным.Ему также не нравилось требование шаблона модуля для переключения на буквальное обозначение объектов для вещей, которые он хотел обнародовать.

в результатом его усилий стал обновленный шаблон, в котором мы просто определяли все наши функции и переменные в частной области и возвращали анонимный объект с указателями на частную функциональность, которую мы хотели показать как общедоступную.

пример того, как использовать шаблон модуля выявления можно найти ниже

преимущества

этот шаблон позволяет синтаксису наших скриптов быть более последовательным. Он также делает в конце модуля более ясно, какие из наших функций и переменных могут быть доступны публично, что облегчает читаемость.

недостатки

недостатком этого шаблона является то, что если частная функция ссылается на публичную функцию, эта публичная функция не может быть переопределена, если необходим патч. Это связано с тем, что функция private будет продолжать ссылаться на частную реализацию, а шаблон не применяется к публичным членам, только к функции.

Читать еще:  Игры на javascript

Public object, которые ссылаются на частные переменные, также подчиняются Примечаниям правила no-patch выше.

после переноса нескольких моих библиотек в разные проекты и постоянного изменения пространства имен верхнего уровня (статически именованного) я переключился на использование этой небольшой вспомогательной функции (с открытым исходным кодом) для определения пространств имен.

описание преимуществ на my блоге. Вы можете захватить здесь исходный код.

одним из преимуществ, которое мне действительно нравится, является изоляция между модулями относительно порядка загрузки. Вы может ссылаться на внешний модуль перед его загрузкой. И ссылка на объект, которую вы получите, будет заполнена, когда код будет доступен.

Я 7 лет опоздал на вечеринку, но сделал совсем немного работы вокруг этого 8 лет назад:

важно иметь возможность легко и эффективно создавать несколько вложенных пространств имен, чтобы держать сложное веб-приложение организованным и управляемый, при уважении глобального пространства имен JavaScript (предотвращение загрязнения пространства имен), и с не clobbering любые существующие объекты в пути пространства имен при этом.

из вышесказанного, это было мое решение около-2008:

это не создает пространство имен, но предоставляет функцию для создания пространств имен.

это можно сконденсировать к minified ОДН-вкладышу:

или, как один заявление:

либо Затем выполняется так:

Если вам не нужна поддержка старых браузеров, обновленная версия:

теперь я бы опасался разоблачения namespace к самому глобальному пространству имен. (Жаль, что базовый язык не обеспечивает этого для нас!) Поэтому я обычно использую это сам в закрытии, например:

в более большом применении, это только нужно быть определенным раз на начало загрузки страницы (для клиентских веб-приложений). Дополнительные файлы могут затем повторно использовать функцию пространства имен, если они сохранены (включены как «необязательные» в приведенном выше). В худшем случае, если эта функция повторно объявлена несколько раз-это всего несколько строк кода, и меньше, если минимизировать.

C++ пространства имен, сравнение с Java пакетами

Я недавно сделал кучу Java кодирования и привык к очень специфическим системам именования пакетов, с глубокой вложенностью, например, com.company.project.db . Это прекрасно работает в Java, AS3/Flex и C#. я видел ту же парадигму, применяемую и в C++, но я также слышал, что плохо рассматривать пространства имен C++ как прямые аналоги пакетов Java.

Так ли это и почему? Как пространства имен / пакеты похожи и отличаются друг от друга? Какие проблемы могут возникнуть, если вы используете глубокие вложенные пространства имен?

7 Ответов

В C++ пространства имен-это просто секционирование доступных имен. Java пакеты относятся к модулям. Иерархия имен-это только один из ее аспектов.

Нет ничего плохого, как такового, с глубоко вложенными пространствами имен в C++, за исключением того, что они обычно не нужны, поскольку за ними нет никакой модульной системы, а дополнительные слои просто добавляют шум. Обычно достаточно иметь один или два уровня пространства имен, с нечетным дополнительным уровнем для внутренних деталей (часто просто называемых деталями).

Существуют также дополнительные правила для пространств имен C++, которые могут застать вас врасплох, если вы злоупотребляете ими, например argument-dependent-lookup, а также правила, связанные с разрешением на родительские уровни. WRT последнее, возьмите:

Это законно? Разве это очевидно, что происходит? Чтобы ответить на эти вопросы, вам необходимо знать, что предшествует разрешению пространства имен.

Java пакеты не являются вложенными, они плоские. Любая видимая вложенность — это не более чем соглашение об именовании.

Например, пакет com.company.project.db не имеет никакого отношения к com.company.project или com.company.project.db.x . Код в com.company.project.db имеет не больше доступа к коду в com.company.project.db.x , чем код в a.b.c .

Вот некоторые причины, почему и как пространства имен C++ отличаются от пространств имен Java или C#.

Избежать конфликтов

В Java/C# языках пространства имен предназначены для предотвращения конфликтов между именами в различных частях библиотек классов. У вас может быть класс с именем «Watcher» в 5 разных местах иерархии пространств имен в C#. в C++, если у вас есть такие же именованные классы, встречающиеся в вашей библиотеке, то вы помещаете их в другой класс вместо того, чтобы создавать пространства имен. Такие вложенные классы все прекрасно и поощряются, и на самом деле синтаксис также рассматривает, как если бы класс был пространством имен с использованием оператора.

Сколько должно быть вложенных пространств имен?

Популярные библиотеки, такие как Boost, Eigen и, конечно же, STL, дают хорошие примеры. в этих библиотеках обычно есть почти все, что помещается в одно пространство имен, например std:: , boost:: или eigen:: . Немногие компоненты получают собственное пространство имен, например std::ios или boost:filesystem . Нет никаких последовательных правил вокруг того, когда использовать второй уровень, но он кажется большим или отдельно разрабатываемым/поддерживаемым или необязательным, как правило, компоненты получают свои собственные пространства имен. Третий уровень встречается еще реже. В основном я использую структуру company::project и для больших независимо используемых подсистем проектов company::project::component .

Предотвращение конфликтов во внешних библиотеках

Теперь большой вопрос: что, если вы получите две библиотеки от двух разных людей, которые имеют точно такие же пространства имен и классы? Эта ситуация довольно редка, потому что большинство людей склонны оборачивать свои библиотеки, по крайней мере, в название своего проекта. Даже если имена проектов совпадают, это еще реже, что вы в конечном итоге используете библиотеки из обоих. Однако иногда плохие решения принимаются для названий проектов (ahm. «metro», «apollo» . ) или даже пространства имен просто не используются вообще. Если это произойдет, вы обернете #include для одной или обеих библиотек в пространство имен, и конфликт будет разрешен! Это одна из причин, почему люди не слишком беспокоятся о конфликтах, потому что их разрешение тривиально. Если вы следуете практике использования company::project , то конфликты становятся очень редкими.

Различия в языке

Хотя C++ предоставляет оператор using namespace точно так же, как C#,, его обычно считают плохой практикой для «import» всего в вашем собственном пространстве имен. Причина этого заключается в том, что заголовок может содержать много «bad» вещей, включая переопределение вещей, которые могут вас полностью удивить. Это совсем не похоже на C#/Java, где вы получаете чистый публичный интерфейс только тогда, когда вы делаете эквивалент using namespace . (боковое примечание: в C++ вы можете достичь того же самого, используя шаблон Pimpl, но обычно это слишком много дополнительной сантехники и несколько библиотек на самом деле делают это). Так что вы почти никогда не захотите делать using namespace . Вместо этого вы делаете typedefs (или using name = ) для того, что вы действительно хотите использовать. Это снова делает глубоко вложенные пространства имен непрактичными в использовании.

Читать еще:  Setbounds в java

Организации код

В Java/C#, люди, как правило, много упорядочивают код в папках. Обычно, когда папка растет более чем на 20 или даже 10 файлов, люди начинают думать о папках. В C++ все более разнообразно , но для многих крупных проектов предпочтительны более плоские структуры каталогов. Например, папка std стандартной библиотеки содержит 53 файла, а проект folly Facebook, похоже, идет тем же путем. Я думаю, что одна из причин этого, вероятно, заключается в том, что Java/C# люди используют visual IDEs больше и используют прокрутки мыши в навигации по папкам, а не в консоли, где вы можете использовать дикие карты для поиска файла в плоской структуре. Кроме того, программисты C++ абсолютно не стесняются помещать несколько классов в один файл и называть файл логической единицей, а не так же, как имя класса, в отличие от C# или Java. Это делает компиляцию быстрее, что очень важно для больших проектов. Хотя на уровне языка не требуется иметь собственное пространство имен для каждой папки, многие разработчики C++ предпочитают назначать каждому каталогу свое собственное пространство имен и поддерживать иерархию папок на уровне 2 или менее уровней.

Возможное исключение

В C++ вы можете ссылаться на A::B::C::D как просто C::D , если вы уже находитесь внутри A::B . Поэтому, если у вас есть частный код или менее используемые классы, которые вы хотите продвинуть дальше вниз, вы можете сделать это, сохраняя свою собственную относительную глубину до 2 или около того. В этом случае вы также можете создать папку для каждого уровня, чтобы расположение файлов было предсказуемым. В целом, в этой области нет золотых стандартов, но вы не хотите переборщить с глубоко вложенными пространствами имен, имитирующими C#/Java.

Разница между пространством имен в С# и пакете в Java

87 Mazzy [2012-02-12 17:00:00]

В чем разница (с точки зрения использования) между пространствами имен в С# и пакетах на Java?

6 ответов

64 Решение RuudVanNistelrooy [2012-02-12 17:23:00]

Джава

Пакеты используются для организации файлов или открытых типов, чтобы избежать конфликтов типов. Конструкции пакета могут быть сопоставлены с файловой системой.

может быть заменено:

Для пакетов нет псевдонима. Вы должны использовать оператор импорта или полное имя, чтобы указать конкретный тип.

Другой исходный файл:

Пакет не может быть вложенным. Один исходный файл может иметь только одну инструкцию пакета.

Пространства имен используются для организации программ как в качестве «внутренней» организационной системы для программы, так и в качестве «внешней» организационной системы.

может быть заменено:

В качестве альтернативы можно указать псевдоним для пространства имен, например

а затем обратиться к классу с

38 Acaz Souza [2012-02-12 17:09:00]

Есть несколько деталей, которые отличаются.

В Java структура каталогов должна соответствовать структуре пакета. нет такое ограничение в С#.

В С# вы можете иметь несколько пространств имен в одном файле. В Java один файл принадлежит одному пакету (см. предыдущий).

Java имеет доступ по умолчанию/пакет. Внутренняя доступность С# в сборках.

Если вы используете VS и Eclipse и пусть они структурируют проект, то вы не почувствуете различий много.

30 Jon Skeet [2012-02-12 17:07:00]

В Java нет такого термина, как «пространство имен» — пакет действует как пространство имен в Java, но с точки зрения предоставления области имен. Это также часть модели доступности.

Программы организованы в виде наборов пакетов. Каждый пакет имеет свой собственный набор имен для типов, что помогает предотвратить конфликты имен. Тип верхнего уровня доступен (§6.6) вне пакета, который объявляет его только в том случае, если тип объявлен публичным.

EDIT: Хорошо, после разъяснения: пакет Java похож на пространство имен С#, за исключением того, что он влияет на доступность, тогда как в пространствах имен С# и доступности полностью ортогональны.

11 kba [2012-02-12 17:08:00]

В С++/С# пространства имен используются только для разделения имен, чтобы избежать коллизий, случайно используя одно и то же имя для переменной в разных местах.

В Java пакеты гораздо больше, чем просто, — пакеты используются для модулей, аспект именования — лишь часть его.

В java вы можете применять различные спецификаторы доступа к классам, которые будут влиять на ваши пакеты.

protected: доступен для одного и того же пакета и его подклассов в другом пакете, default: доступно для одного и того же пакета, общественность: общедоступная, private: даже не доступен для одного и того же пакета.

Эти типы спецификаторов доступа не применимы к пространству имен в c sharp

Пространство имен похоже на новую папку, все подпапки являются подпространствами имен. Если мы рассматриваем пространство имен как функцию, подобную рекламе в пространстве имен в рамках маркетингового пространства имен, то мы используем marketing.advertising.adsclass.adsmethod. Очень легко решить проблему. Java имеет тот же метод через пакет, но сложный для новичков.

» ‘маркетинг пространства имен <

Использовать в классе клиента

«В Java вы используете тот же метод. Вы упаковываете несколько классов в один пакет и используете его много раз. Это увеличивает уникальность. Вы пишете один раз и используете много раз. Связанные классы в одном пакете. Не нужно много раз кодировать.

Javascript. Шаблоны проектирования. Пространство имен.

Шаблоны проектирования, предлагают решение наиболее типичных задач, связанных с архитектурой объектно-ориентированного программного обеспечения. Они достаточно давно используются на практике и доказали свою полезность во многих ситуациях. Именно поэтому и вам будет полезно познакомиться с ними и обсудить их.

Хотя эти шаблоны проектирования могут применяться в любом языке программирования, тем не менее многие годы они изучаются с позиций языков со строгим контролем типов и со статическими классами, таких как C++ и Java.

JavaScript, будучи динамическим нетипизированным языком, опирающимся на использование прототипов, иногда позволяет удивительно легко и даже тривиально реализовать некоторые их этих шаблонов.

Нами будут рассмотрены следующие шаблоны проектирования:

  • Пространство имен
  • Частные свойства и методы
  • Модуль
  • Шаблон модуль выявление
  • Одиночка
  • Наблюдатель
  • Посредник
  • Прототип
  • Команда
  • Фасад
  • Фабричный метод
  • Смешанный шаблон
  • Декоратор
  • Приспособленец

Часть 3.1 Шаблон “Пространство имен”

Пространства имен помогают уменьшить количество глобальных переменных, необходимых нашим программам, и одновременно избежать конфликтов имен и чрезмерного употребления префиксов.

Взгляните на следующий пример:

Такой программный код легко переписать иным способом, создав единственный глобальный объект, назовем его MYAPP, и превратив все функции и переменные в свойства этого глобального объекта:

С ростом сложности программы некоторые фрагменты программного кода приходится выносить в отдельные файлы и подключать их при определенных условиях. Вследствие этого становится безосновательным предполагать, что ваш файл первым определит некоторое пространство имен или свойство в нем. Вполне возможно, что некоторые свойства, которые предполагается добавить, уже существуют, и вы можете затереть их по неосторожности. Поэтому, прежде чем добавлять свойство или создавать пространство имен, желательно убедиться, что оно еще не создано.

Читать еще:  Java lang exceptionininitializererror java lang exceptionininitializererror

Поэтому было бы очень удобно иметь функцию, которая взяла бы на себя выполнение всех операций, необходимых для создания пространства имен. Назовем эту функцию namespace() и положим, что она должна использоваться, как показано ниже:

Далее приводится пример реализации этой функции, в котором использован принцип неразрушения, то есть если пространство имен с заданным именем уже существует, оно не будет создано заново:

Такая реализация делает допустимыми все следующие варианты использования функции:

Часть 3.2 Шаблон “Частные свойства и методы”

В языке JavaScript нет специальных средств объявления частных (private), защищенных (protected) или общедоступных (public) свойств и методов, как в языке Java или в других языках. Все члены объектов в этом языке являются общедоступными:

To же справедливо и при использовании функций-конструкторов для создания объектов — все члены являются общедоступными:

Несмотря на отсутствие в языке специальных средств определения частных членов, их все-таки можно создать, используя для этого замыкания. Функция-конструктор может образовывать замыкание, и любые переменные, ставшие частью этого замыкания, не будут доступны за пределами объекта. Однако такие частные члены останутся доступными для общедоступных методов — методов, определяемых внутри конструктора и являющихся частью интерфейса возвращаемого объекта. Давайте рассмотрим пример создания частного члена, недоступного за пределами объекта:

Как видите, в JavaScript можно легко создавать частные члены. Все, что для этого необходимо, — обернуть данные, которые вы хотели бы оставить частными, в функцию, сделав их локальными по отношению к этой функции и, следовательно, недоступными за пределами функции.

До сих пор все примеры реализации частных свойств, которые мы видели, были основаны на использовании конструкторов. А как быть в случаях, когда объекты определяются в виде литералов? Возможно ли в таких ситуациях создавать частные члены? Как вы уже видели, чтобы обеспечить сокрытие данных, их необходимо обернуть функцией. Так, в случае литералов объектов замыкание можно создать с помощью дополнительной анонимной функции, вызываемой немедленно. Например:

Та же идея положена в основу следующего примера, имеющего несколько иную реализацию:

Этот шаблон является также основой шаблона, известного под названием «модуль», исследованием которого мы займемся чуть ниже.

Один из недостатков создания частных членов с применением конструкторов заключается в том, что они создаются всякий раз, когда вызывается конструктор для создания нового объекта.

Фактически эта проблема относится ко всем членам, добавляемым внутри конструкторов. Чтобы сэкономить свои усилия и память, общие для всех экземпляров свойства и методы можно добавить в свойство prototype конструктора. При таком подходе общие члены будут совместно использоваться всеми экземплярами, созданными с помощью одного и того же конструктора. Аналогичным образом можно определять частные свойства, совместно используемые всеми экземплярами. Для этого необходимо применить комбинацию из двух шаблонов: частные свойства внутри конструкторов и частные свойства в литералах объектов. Так как свойство prototype является обычным объектом, его можно определить в виде литерала.

Как это сделать, показано в следующем примере:

Разница между пространством имен в С# и пакете в Java

87 Mazzy [2012-02-12 17:00:00]

В чем разница (с точки зрения использования) между пространствами имен в С# и пакетах на Java?

6 ответов

64 Решение RuudVanNistelrooy [2012-02-12 17:23:00]

Джава

Пакеты используются для организации файлов или открытых типов, чтобы избежать конфликтов типов. Конструкции пакета могут быть сопоставлены с файловой системой.

может быть заменено:

Для пакетов нет псевдонима. Вы должны использовать оператор импорта или полное имя, чтобы указать конкретный тип.

Другой исходный файл:

Пакет не может быть вложенным. Один исходный файл может иметь только одну инструкцию пакета.

Пространства имен используются для организации программ как в качестве «внутренней» организационной системы для программы, так и в качестве «внешней» организационной системы.

может быть заменено:

В качестве альтернативы можно указать псевдоним для пространства имен, например

а затем обратиться к классу с

38 Acaz Souza [2012-02-12 17:09:00]

Есть несколько деталей, которые отличаются.

В Java структура каталогов должна соответствовать структуре пакета. нет такое ограничение в С#.

В С# вы можете иметь несколько пространств имен в одном файле. В Java один файл принадлежит одному пакету (см. предыдущий).

Java имеет доступ по умолчанию/пакет. Внутренняя доступность С# в сборках.

Если вы используете VS и Eclipse и пусть они структурируют проект, то вы не почувствуете различий много.

30 Jon Skeet [2012-02-12 17:07:00]

В Java нет такого термина, как «пространство имен» — пакет действует как пространство имен в Java, но с точки зрения предоставления области имен. Это также часть модели доступности.

Программы организованы в виде наборов пакетов. Каждый пакет имеет свой собственный набор имен для типов, что помогает предотвратить конфликты имен. Тип верхнего уровня доступен (§6.6) вне пакета, который объявляет его только в том случае, если тип объявлен публичным.

EDIT: Хорошо, после разъяснения: пакет Java похож на пространство имен С#, за исключением того, что он влияет на доступность, тогда как в пространствах имен С# и доступности полностью ортогональны.

11 kba [2012-02-12 17:08:00]

В С++/С# пространства имен используются только для разделения имен, чтобы избежать коллизий, случайно используя одно и то же имя для переменной в разных местах.

В Java пакеты гораздо больше, чем просто, — пакеты используются для модулей, аспект именования — лишь часть его.

В java вы можете применять различные спецификаторы доступа к классам, которые будут влиять на ваши пакеты.

protected: доступен для одного и того же пакета и его подклассов в другом пакете, default: доступно для одного и того же пакета, общественность: общедоступная, private: даже не доступен для одного и того же пакета.

Эти типы спецификаторов доступа не применимы к пространству имен в c sharp

Пространство имен похоже на новую папку, все подпапки являются подпространствами имен. Если мы рассматриваем пространство имен как функцию, подобную рекламе в пространстве имен в рамках маркетингового пространства имен, то мы используем marketing.advertising.adsclass.adsmethod. Очень легко решить проблему. Java имеет тот же метод через пакет, но сложный для новичков.

» ‘маркетинг пространства имен <

Использовать в классе клиента

«В Java вы используете тот же метод. Вы упаковываете несколько классов в один пакет и используете его много раз. Это увеличивает уникальность. Вы пишете один раз и используете много раз. Связанные классы в одном пакете. Не нужно много раз кодировать.

Ссылка на основную публикацию
Adblock
detector