Принцип компьютерного программирования

Обновлено: 04.07.2024

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

Понимая основные принципы программирования, вы знакомитесь с этими различными языками программирования и этапами создания программного обеспечения.

Оглавление

Языки программирования

Существует две основные категории языков программирования:

  1. Языки низкого уровня.
  2. Языки высокого уровня.

Языки низкого уровня

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

Классификация языков низкого уровня

Машинный язык

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

Язык ассемблера

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

Языки высокого уровня

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

Классификация языков высокого уровня

Языки третьего поколения

Их инструкции записываются в последовательности или в определенном порядке, в котором они выполняются. Особое внимание уделяется использованию управляющих структур.

Примерами языков третьего поколения являются Fortran, ALGOL, BASIC, C, COBOL, Java, Pascal.

Языки четвертого поколения

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

Примерами языков четвертого поколения являются SQL, Oracle, PHP.

Языки пятого поколения

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

Примерами языков пятого поколения являются Mercury, Prolog, OPS5

Объектно-ориентированные языки программирования

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

Примерами ООП являются C++, Java, Smalltalk, Visual Basic.

Языки веб-скриптов

Они создают/добавляют изображения на веб-страницу. Языки веб-скриптов не имеют ни частей объявлений, ни управляющих структур.

Примерами языков веб-скриптов являются JavaScript, XML, Perl, Python, Ruby, Groovy.

Разработка программы

Разработка программы относится к процессу создания программного обеспечения и подразделяется на следующие этапы:

  1. Распознавание проблемы. Здесь программист должен понять и интерпретировать проблему.
  2. Постановка задачи. Программист определяет необходимые входные данные, действия по обработке и выходные данные. Программист также определяет пути решения одной и той же проблемы и выбирает лучший. На этапе проектирования требуется письменная документация.
  3. Разработка программы. На этом этапе программист разрабатывает проект решения проблемы, называемый алгоритмом, который представляет собой ограниченное количество логических шагов, которым программа следует для решения проблемы. На этом этапе полезны такие инструменты, как псевдокоды, блок-схемы и таблицы решений.
  4. Программное кодирование. Алгоритм преобразуется в аналогичный код языка программирования. При кодировании программ программист может использовать различные управляющие структуры.

Структуры управления программой

Управление последовательностью

Здесь компьютер читает инструкции из файла программы от первого оператора до последнего.

Ниже приведен пример управляющих структур Sequence в форме псевдокода:

Структуры управления выбором

Выражение выполняется, если условие возвращает значение true или false .

Условие должно быть логическим выражением.

Существуют различные типы структур управления выбором.

Условие if используется, когда доступен только один вариант.

Когда условие истинно, все остальные параметры игнорируются.

Его синтаксис в общем виде:

2. Если иначе

Подходит, когда есть два доступных варианта.

Например, если условие истинно, выполняется оператор, если ложно, выполняется альтернативный оператор.

Его синтаксис в общем виде:

3. If Else If (вложенный If)

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

Его синтаксис в общем виде:

Контрольные структуры цикла

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

Существуют различные типы структур управления циклами.

1. Цикл while

Цикл while используется, если условие выполняется до того, как операторы внутри цикла будут выполнены. Его синтаксис в общем виде:

2. Повторять до

Это позволяет операторам выполняться хотя бы один раз.

Инструкции выполняются до тех пор, пока условие не станет истинным.

Его синтаксис в общем виде:

3. Для цикла

В этом цикле операторы повторяются заданное количество раз.

Его синтаксис в общем виде:

Примечание. Эти управляющие структуры имеют разные форматы в разных языках программирования.

Для дальнейшего чтения вы можете проверить эту статью.

Тестирование и отладка программы

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

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

Ошибки, которые могут возникнуть в программе, – это синтаксические ошибки и логические ошибки.

Реализация программы

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

Просмотр и обслуживание программы

Проверка и обслуживание необходимы из-за ошибок, возникающих после внедрения.

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

Документация по программе

Документация программы – это письменный текст, объясняющий процесс разработки программы.

Это поможет при модификации программы в будущем.

Документация может быть внутренней или внешней.

Внутренняя документация — это письменные комментарии к исходной программе, которые помогают другим программистам понять код.

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

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

Инструменты для разработки интерфейса

Внешние технологии помогают разрабатывать пользовательский интерфейс веб-приложений и веб-страниц.

  • Инструменты разработчика Chrome
  • Шаблон HTML5
  • Сасс
  • AngularJS
  • JQuery
  • Код Visual Studio
  • Гит
  • NPM (диспетчер пакетов узла)
  • Хрюканье

Инструменты для внутренней разработки

Бэкенд-технология помогает разрабатывать серверные операции веб-приложений и веб-страниц.

  • Ларавел
  • Джанго
  • Угловой
  • Метеор
  • Весна
  • Руби на рельсах

Заключение

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

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

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

Писать код легко. Написать хороший код сложно.

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

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

Как написать эффективный код? Будучи дисциплинированным и целеустремленным. Вот 10 принципов программирования, которые сделают вас лучшим программистом.

1. Будь проще, глупец (KISS)

Звучит несколько резко, но это один из самых важных принципов кодирования, которому нужно следовать. Что означает ПОЦЕЛУЙ?

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

Вот простая функция:

Довольно просто. Его легко читать, и вы точно знаете, что происходит.

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

2. Напишите СУХОЙ код

Принцип компьютерного программирования "Не повторяйся" (DRY) означает, что код не должен повторяться. Это распространенная ошибка кодирования. При написании кода избегайте дублирования данных или логики. Если вы когда-либо копировали и вставляли код в свою программу, это не СУХОЙ код.

Взгляните на этот скрипт:

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

DRY код прост в обслуживании.Легче отладить один цикл, который обрабатывает 50 повторений, чем 50 блоков кода, каждый из которых обрабатывает одно повторение.

3. Открыто/Закрыто

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

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

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

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

4. Композиция важнее наследования

Если вы пишете код с использованием объектно-ориентированного программирования, вы обнаружите, что этот принцип программирования очень полезен. Принцип композиции над наследованием гласит: объекты со сложным поведением должны содержать экземпляры объектов с индивидуальным поведением. Они не должны наследовать класс и добавлять новое поведение.

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

5. Единая ответственность

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

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

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

6. Разделение интересов

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

Хорошо известный пример — модель-представление-контроллер (MVC). MVC разделяет программу на три отдельные области: данные (модель), логика (контроллер) и то, что отображается на странице (представление). Варианты MVC распространены в самых популярных современных веб-фреймворках.

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

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

7. Вам это не понадобится (ЯГНИ)

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

Пытаясь написать СУХОЙ код, программисты могут нарушать этот принцип. Часто неопытные программисты пытаются написать как можно более абстрактный и универсальный код. Однако излишняя абстракция приводит к раздуванию кода, который невозможно поддерживать.

Применяйте принципы СУХОГО программирования только тогда, когда это необходимо; если вы заметили куски кода, написанные снова и снова, реализуйте уровень абстракции. Не заглядывайте слишком далеко вперед за счет текущей партии кода.

8. Документируйте свой код

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

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

Вот функция JavaScript с комментариями, которые помогут вам в коде:

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

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

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

9. Рефакторинг

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

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

10. Чистый код любой ценой

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

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

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

Изучение принципов компьютерного программирования: что делает хорошего программиста?

Чтобы научиться быть хорошим программистом, требуется немало времени и усилий. Эти 10 правил базового программирования помогут вам стать профессиональным программистом.

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

Присоединяйтесь к сообществу DZone и получите все возможности участника.

Принципы объектно-ориентированного проектирования являются основой ООП-программирования. Тем не менее, я видел, как большинство Java-программистов гонялись за шаблонами проектирования, такими как шаблон Singleton, шаблон Decorator или Observer, и не уделяли достаточно внимания изучению объектно-ориентированного анализа и проектирования.

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

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

Я регулярно встречал Java-программистов и разработчиков с разным уровнем опыта, которые либо никогда не слышали об этих принципах проектирования ООП и SOLID, либо не знали, какие преимущества дает тот или иной принцип проектирования и как применять эти принципы проектирования в программировании. .

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

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

Вы также можете присоединиться к комплексному курсу по объектно-ориентированному дизайну, такому как SOLID Principles of Object-Oriented Design Стива Смита на Pluralsight. Это очень помогло мне в понимании и применении этих принципов.

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

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

10 принципов объектно-ориентированного и SOLID-дизайна для программистов

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

принципы ООП

Я думаю, что каждый из этих принципов проектирования ООП и SOLID нуждается в статье, чтобы объяснить их ясно, и я попытаюсь сделать это здесь, а пока приготовьтесь к быстрой поездке на велосипеде по городу принципов дизайна :)

1. СУХОЙ (Не повторяйтесь)

Наш первый принцип объектно-ориентированного проектирования — СУХОЙ, как следует из названия, СУХОЙ (не повторяйтесь) означает не писать повторяющийся код, а использовать абстракцию для абстрагирования повседневных вещей в одном месте.

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

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

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

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

Так что остерегайтесь такого связывания и не объединяйте ничего, что использует похожий код, но не связано. Кроме того, вы можете ознакомиться с курсом «Основы архитектуры программного обеспечения и шаблонов проектирования в Java» на Udemy, чтобы узнать больше о написании правильного кода и рекомендациях, которым следует следовать при проектировании системы.

2. Инкапсулируйте изменения

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

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

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

Несколько шаблонов проектирования в Java используют инкапсуляцию; шаблон проектирования Factory — это один из примеров инкапсуляции, который инкапсулирует код создания объекта и обеспечивает гибкость для добавления нового продукта позже, не затрагивая существующий код.

Кстати, если вы хотите узнать больше о шаблонах проектирования в Java и объектно-ориентированном программировании, то вы должны просмотреть этот курс «Библиотека шаблонов проектирования» на Pluralsight. Это одна из лучших коллекций шаблонов проектирования и советов по их использованию в реальном мире.

3. Принцип открытого закрытого дизайна

В соответствии с этим принципом проектирования ООП «классы, методы или функции должны быть открыты для расширения (новые функции) и закрыты для модификации».

Это еще один прекрасный принцип проектирования SOLID, придуманный дядей Бобом в его классической книге "Чистый код", который предотвращает изменение уже испытанного кода.

Ключевым преимуществом этого принципа проектирования является то, что уже испытанный и протестированный код не затрагивается а значит, он не сломается.< /em>

Вот пример кода Java, который нарушает принцип открытого-закрытого проектирования в программировании:

В этом коде GraphicEditor тесно связан с Shape. Если вам нужна новая форма, вам нужно изменить уже испытанную и протестированную систему внутри метода drawShape(Shape s), который подвержен ошибкам и нежелателен.

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

Кстати, принцип Open-Closed — это буква «О» от аббревиатуры SOLID. Если вы хотите узнать больше об этом принципе, курс SOLID Principles of Object-Oriented Design and Architecture на Udemy — один из лучших ресурсов для консультации.

4. Принцип единой ответственности (SRP)

Принцип единой ответственности — это еще один принцип разработки SOLID, который представляет собой букву «S» в аббревиатуре SOLID. В соответствии с SRP не должно быть более одной причины для изменения класса, или уровень всегда должен обрабатывать одну функциональность.

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

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

Вы также можете просмотреть курс From 0 to 1: Design Patterns — 24 That Matter на Udemy, чтобы узнать о шаблонах, основанных на этом принципе.

5. Внедрение зависимостей или принцип инверсии

Не требуйте зависимости; он будет предоставлен вам фреймворком. Это было очень хорошо реализовано в среде Spring, одной из самых популярных сред Java для написания реальных приложений.

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

Существует несколько способов реализации внедрения зависимостей, например использование инструментария байт-кода, как в некоторых фреймворках АОП (аспектно-ориентированного программирования), таких как AspectJ, или использование прокси-серверов, как это используется в Spring.

Вы можете также просмотреть курс SOLID Principles of Object-Oriented Design and Architecture на Udemy, чтобы узнать больше об этом полезном принципе. Он также представляет букву «D» в аббревиатуре SOLID.

Вот пример кода, который нарушает принцип инверсии зависимостей или DIP в Java:

Вы можете видеть, что AppManager зависит от EventLogWriter, который тесно связан с AppManager. Если вам нужно использовать другой способ уведомления вашего клиента, например, отправку push-уведомлений, SMS или электронную почту, вам нужно изменить класс AppManager.

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

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

6. Предпочтение композиции наследованию

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

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

Даже в книге Джошуа Блоха «Эффективная Java» рекомендуется отдавать предпочтение композиции, а не наследованию. Если вы все еще не убеждены, вы также можете прочитать здесь, чтобы узнать больше о том, почему ваша композиция лучше, чем наследование для повторного использования кода и функциональности.

И если вы все время забываете об этом правиле, вот вам отличный мультфильм на рабочий стол :-)

Если вам интересно узнать больше о концепциях объектно-ориентированного программирования, таких как композиция, наследование, ассоциация, агрегация и т. д., вы также можете ознакомиться с курсом "Объектно-ориентированное программирование на Java" на Coursera.

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

7. Принцип замещения Лискова (LSP)

Согласно принципу подстановки Лискова, подтипы должны быть взаимозаменяемыми для супертипа. Я имею в виду, что методы или функции, использующие тип суперкласса, должны без проблем работать с объектом подкласса».

LSP тесно связан с принципом единой ответственности и принципом разделения интерфейса.

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

Чтобы следовать принципу проектирования LSP SOLID, производный класс или подкласс должны расширять функциональные возможности, а не уменьшать их. LSP представляет собой букву L в аббревиатуре SOLID.

Вот пример кода, который нарушает принцип подстановки Лискова в Java:

Принцип подстановки Лисков в Java

Если у вас есть метод area(Rectangle r), который вычисляет площадь прямоугольника, тогда этот код сломается, когда вы пройдете квадрат, потому что квадрат на самом деле не прямоугольник.

Если вас интересует более реальный пример, курс SOLID Principles of Object-Oriented Design на Pluralsight — отличный курс для начала.

8. Принцип разделения интерфейсов (ISP)

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

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

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

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

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

9. Программирование интерфейса без реализации

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

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

Список номеров= getNumbers();

Числа ArrayList = getNumbers();

Это также рекомендуется во многих книгах по Java, в том числе в книге по шаблонам проектирования Effective Java и Head First.

10. Принципы делегирования

Не делайте все самостоятельно, делегируйте это соответствующему классу. Классическим примером принципа делегирования является метод equals() и hashCode() в Java.

Чтобы сравнить два объекта на равенство, мы просим сам класс выполнить сравнение, а не клиент класс, выполняющий эту проверку. em>

Ключевым преимуществом этого принципа проектирования является отсутствие дублирования кода и простота изменения поведения. Делегирование события — еще один пример этого принципа, когда событие делегируется обработчикам для обработки.

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

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

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

Если вы ищете хороший курс для начала, я предлагаю вам присоединиться к курсу From 0 to 1: Design Patterns — 24 That Matter — In Java на Udemy. Он очень всеобъемлющий, и вы можете получить его всего за 11 долларов США за несколько флэш-продаж.

В любом случае, вот хорошее резюме всех этих принципов проектирования ООП.

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

Суть в том, что профессиональные программисты всегда должны стремиться к четкому и слабо связанному решению, коду или дизайну. Просмотр открытого исходного кода от Apache и Google — хороший способ изучить принципы проектирования Java и ООП.

Если вы заинтересованы в изучении принципов и паттернов объектно-ориентированного программирования, вы можете ознакомиться с еще одной моей любимой книгой Head First Object-Oriented Analysis and Design, отличной книгой и, вероятно, лучшим материалом по объектно-ориентированному анализу и проектированию.

Немногие программисты знают эту книгу, потому что ее часто затмевает ее более популярный двоюродный брат Эрика Фримана Head First Design Pattern, в котором больше рассказывается о том, как эти принципы объединяются для создания шаблона, который можно использовать непосредственно для решения известных проблем.< /p>

Эти книги очень помогают писать более качественный код, в полной мере используя различные принципы объектно-ориентированного проектирования и проектирования SOLID. Кстати, если вас действительно больше интересуют методы написания кода на Java, то прочитайте «Эффективное использование Java 3rd Edition» Джошуа Блоха, жемчужины автора, написавшего Java Collection API.

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

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

Публикуется на DZone с разрешения Джавина Пола, DZone MVB. Смотрите оригинальную статью здесь.

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


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

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

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

7 общих принципов программирования

<р>1. KISS: Никто из программистов не любит отлаживать, поддерживать или вносить изменения в сложный код. "Keep It Simple, Stupid (KISS)" утверждает, что большинство систем работают лучше всего, если они остаются простыми, а не усложняются, поэтому, когда вы пишете код, ваше решение не должно быть сложным, что требует много времени. времени и усилий, чтобы понять. Если ваш код прост, у других разработчиков не возникнет проблем с пониманием логики кода, и они смогут легко продолжить работу с вашим кодом. Поэтому всегда старайтесь упростить свой код, используя различные подходы, такие как разбиение сложной задачи на более мелкие части или удаление ненужного кода, который вы написали.

Цель разработки программного обеспечения — уменьшить сложность, а не создать ее.
— Памела Зейв

<р>2. СУХОЙ: Дублирование данных, логики или функций в коде не только удлиняет ваш код, но и отнимает много времени, когда речь идет об обслуживании, отладке или изменении кода. Если вам нужно внести небольшое изменение в свой код, вам нужно сделать это в нескольких местах. Основная цель Не повторяйтесь (DRY) – уменьшить повторение кода. В нем говорится, что часть кода должна быть реализована только в одном месте исходного кода. Противоположностью СУХОГО принципа является ВЛАЖНЫЙ («пишите все дважды» или «тратите время всех впустую»), который нарушает СУХОЙ принцип, если вы пишете одну и ту же логику в нескольких местах. Вы можете создать общую функцию или абстрагировать свой код, чтобы избежать повторения кода.

<р>3. YAGNI: Ваше программное обеспечение или программа может стать больше и сложнее, если вы пишете код, который может понадобиться вам в будущем, но не в данный момент. Принцип «Вам это не понадобится (YAGNI)» гласит, что «не внедряйте что-либо, пока в этом нет необходимости», потому что в большинстве случаев вы не собираетесь использовать этот фрагмент кода в будущее. Большинство программистов при внедрении программного обеспечения думают о будущих возможностях и добавляют код или логику для некоторых других функций, которые им не нужны в настоящее время. Они добавляют весь ненужный класс и функциональность, которые они никогда не смогут использовать в будущем. Делать это совершенно неправильно, и в конечном итоге вы напишете раздутый код, а ваш проект станет сложным и сложным в обслуживании. Мы рекомендуем всем программистам избегать этой ошибки, чтобы сэкономить много времени и сил.

<р>4. SOLID: принцип SOLID означает пять принципов: единая ответственность, открытость-закрытость, замена Лискова, разделение интерфейса и инверсия зависимостей. Эти принципы даны Робертом С. Мартином, и вы можете подробно ознакомиться с этими принципами SOLID.

<р>5. Разделение задач (SoC): Принцип разделения задач разбивает сложное приложение на разные разделы или домены. Каждый раздел или область решает отдельную проблему или выполняет определенную работу.Каждый раздел независим друг от друга, поэтому с каждым разделом можно работать независимо, а также упрощается поддержка, обновление и повторное использование кода.
Например, бизнес-логика (содержимое веб-страницы) в приложении — это другая проблема и пользовательский интерфейс - это другая проблема в программе веб-приложения. Одним из хороших примеров SoC является шаблон MVC, в котором данные («модель»), логика («контроллер») и то, что видит конечный пользователь («представление»), разделены на три разных раздела, и каждая часть обрабатывается независимо. . Сохранение данных в базе данных не имеет ничего общего с отображением данных в Интернете.

<р>6. Избегайте преждевременной оптимизации. Оптимизация действительно помогает ускорить работу программы или алгоритма, но в соответствии с этим принципом вам не нужно оптимизировать алгоритм на ранней стадии разработки. Если вы сделаете преждевременную оптимизацию, вы не сможете узнать, где будут узкие места программы, и вам станет сложнее поддерживать ее. Если вы оптимизируете свой код в начале и в случае, если требования могут измениться, ваши усилия будут потрачены впустую, а ваш код отправится в мусор. Поэтому лучше оптимизировать алгоритм в нужное время, чтобы получить от него правильную выгоду.

Преждевременная оптимизация — корень всех зол в программировании.
– Дональд Кнут

  • Каждый блок должен иметь лишь ограниченные знания о других блоках: только блоки, "тесно" связанные с текущим блоком.
  • Каждый юнит должен разговаривать только со своими друзьями; не разговаривай с незнакомцами.
  • Разговаривайте только со своими ближайшими друзьями.

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

Читайте также: