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

Введение

Почти все популярные языки программирования являются объектно-ориентированными. В таблице приведены данные о популярности языков (рейтинг TIOBE) за сентябрь 2019 года :

Не являются объектно-ориентированными лишь 20% — это языки программирования аппаратуры (Си, Assembly language), декларативный язык программирования баз данных (SQL) и визуальный язык MATLAB. Не удивительно, что почти в каждом описании вакансии программиста требуется что-то типа «Понимание ООП» или «Понимание принципов SOLID» (что очень близко).

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

В этой статье-учебнике:

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

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

Разделение на функции

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

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

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

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

Абстракция

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

Простой пример: представьте, что мы создаём картотеку сотрудников компании. Естественно, мы вносим их основные характеристики: дату рождения, ИНН, ФИО, номер социального страхования. Разумеется, нас не интересуют ни рост, ни цвет глаз, ни длина волос. То есть мы абстрагируемся от ненужной информации.

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

Принципы ООП

Абстракция

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

Любой составной объект реального мира – это абстракция. Говоря «ноутбук», вам не требуется дальнейших пояснений, вроде того, что это организованный набор пластика, металла, жидкокристаллического дисплея и микросхем. Абстракция позволяет игнорировать нерелевантные детали, поэтому для нашего сознания это один из главных способов справляться со сложностью реального мира. Если б, подходя к холодильнику, вы должны были иметь дело с отдельно металлом корпуса, пластиковыми фрагментами, лакокрасочным слоем и мотором, вы вряд ли смогли бы достать из морозилки замороженную клубнику.

Полиморфизм

Полиморфизм подразумевает возможность нескольких реализаций одной идеи. Простой пример: у вас есть класс «Персонаж», а у него есть метод «Атаковать». Для воина это будет означать удар мечом, для рейнджера – выстрел из лука, а для волшебника – чтение заклинания «Огненный Шар». В сущности, все эти три действия – атака, но в программном коде они будут реализованы совершенно по-разному.

Наследование

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

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

Инкапсуляция

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

Вы разработали для муниципальных служб класс «Квартира». У неё есть свойства вроде адреса, метража и высоты потолков. И методы, такие как получение информации о каждом из этих свойств и, главное, метод, реализующий постановку на учёт в Росреестре. Это готовая концепция, и вам не нужно чтобы кто-то мог добавлять методы «открыть дверь» и «получить место хранения денег». Это А) Небезопасно и Б) Избыточно, а также, в рамках выбранной реализации, не нужно. Работникам Росреестра не требуется заходить к вам домой, чтобы узнать высоту потолков – они пользуются только теми документами, которые вы сами им предоставили.

Полиморфизм

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

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

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

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

Аналогия

Можно представить объекты отделами компании. В большинстве организаций сотрудники не работают один день с кадрами, на следующий начисляя зарплату, а затем неделю занимаясь розничной торговлей. У каждого отдела есть свой персонал с четко возложенными на него обязанностями. Есть и собственные данные: показатели заработной платы, продаж, учет сотрудников и т. д. Люди в отделах работают со своей информацией. Разделение компании, таким образом, облегчает контроль за ее деятельностью и поддерживает целостность данных. Бухгалтерия отвечает за платежные ведомости. Если необходимо знать общую сумму заработной платы, выплачиваемой в южном филиале в июле, не нужно рыться в архиве. Достаточно направить записку ответственному лицу, подождать, пока этот человек получит доступ к данным и отправит ответ с требуемой информацией. Это гарантирует соответствие регламенту и отсутствие постороннего вмешательства. Таким же образом объект в ООП обеспечивает организацию приложения.

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

Инкапсуляция в Java

Инкапсуляция — принцип, согласно которому атрибуты объекта заключаются в этот объект. Это задает для атрибутов контекст. Это также позволяет программисту ограничить доступ к атрибутам, чтобы они изменялись и использовались только через методы, которые программист собирается применять:

// Эта переменная не инкапсулирована.
// Поэтому в ней отсутствует какой-то контекст.
String name;
// БАЗОВАЯ ИНКАПСУЛЯЦИЯ
// Эти переменные и методы инкапсулированы в классе Dog. Они являются его членами.
class Dog {
    String name;
    int age;
    void bark() {
        System.out.println("Bark!");
    }
    void rename(String newName) {
        name = newName;
    }
}
// МОДИФИКАТОРЫ ДОСТУПА
// Приведенные выше члены доступны для любого другого
// класса. Чтобы определить доступы, используются модификаторы доступа:
// - default: Если модификаторы доступа отсутствуют, атрибут доступен
//    только для классов внутри одного пакета.
// - public: атрибут доступен из любого другого класса.
// - protected: То же самое, что и default, плюс он доступен для подклассов.
// - private: доступен только внутри объявленного класса.
class Dog {
    private String name;
    private int age;
    void bark() {
        System.out.println("Bark!");
    }
    void rename(String newName) {
        name = newName;
    }
    public String getName() {
        return name;
    }
    public void setAge(int newAge) {
        if(newAge > 0)
            age = newAge;
    }
    public int getAge() {
        return age;
    }
}

Понятие «объект» в ООП

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

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

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

Свойства объекта в JavaScript

В JavaScript объект имеет свойства, ассоциированные с ним. Свойство объекта:

  • можно понимать как переменную, закрепленную за объектом;
  • определяют характеристики объекта.

Получение доступа к свойству объекта:

JavaScript

objectName.propertyName
// или
objectName

1
2
3

objectName.propertyName

// или

objectName»propertyName»

Примеры:

JavaScript

var myCar = new Object(); // создание объекта с помощью конструктора
myCar.make = «Ford»;
myCar.model = «Mustang»;
myCar.year = 1969;

// или
myCar = «Ford»;
myCar = «Mustang»;
myCar = 1969;

1
2
3
4
5
6
7
8
9

varmyCar=newObject();// создание объекта с помощью конструктора

myCar.make=»Ford»;

myCar.model=»Mustang»;

myCar.year=1969;

 
// или

myCar»make»=»Ford»;

myCar»model»=»Mustang»;

myCar»year»=1969;

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

Примеры

JavaScript

var myObj = new Object(),
str = «myString»,
rand = Math.random(),
obj = new Object();

myObj.type = «Dot syntax»;
myObj = «String with space»;
myObj = «String value»;
myObj = «Random Number»;
myObj = «Object»;
myObj = «Even an empty string»;

console.log(myObj);

1
2
3
4
5
6
7
8
9
10
11
12
13

varmyObj=newObject(),

str=»myString»,

rand=Math.random(),

obj=newObject();

myObj.type=»Dot syntax»;

myObj»date created»=»String with space»;

myObjstr=»String value»;

myObjrand=»Random Number»;

myObjobj=»Object»;

myObj»»=»Even an empty string»;

console.log(myObj);

Обратите внимание, что все ключи с квадратными скобками преобразуются в тип String, поскольку объекты в JavaScript могут иметь в качестве ключа только тип String. Например, в приведенном выше коде, когда ключ obj добавляется в myObj, JavaScript вызывает метод obj.toString () и использует эту результирующую строку в качестве нового ключа

Класс

Класс — это такой тип данных, который состоит из единого набора полей и методов.

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

  • наследования;
  • ассоциации;
  • агрегации.

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

Одной из главных характеристик является область видимости. Понятие по-разному определяется разными ЯП.

В Object Pascal описывается следующим образом:

ClassName = class(SuperClass)

private

{ использование элементов ограничивается только пределами модуля }

{ здесь указываются поля }

strict private

{ спецификатор доступа стал доступным с выходом Delphi 2007, обозначает то же, что и private }

protected

{ элементы могут использоваться внутри ClassName или при наследовании }

public

{ }

published

{ элементы доступны всем, они отображаются в Object Inspector’e }

end;

Здесь SuperClass — предок, от которого происходит наследование.

Для C++ создание выглядит так:

class MyClass: public Parent

{

public:

MyClass(); // конструктор

~MyClass(); // деструктор

protected:

private:

};

В этом примере Parent является предком, если таковой имеется. Спецификаторы private, public, protected обозначают то же самое, что в предыдущем примере на Паскале. Также мы видим конструктор, деструктор, доступные для любой части программы. У C++ все элементы по умолчанию являются private, соответственно, это можно не указывать.

3 Что учить дальше?

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

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

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

3.1 Список использованных источников

  1. Рейтинг популярности языков программирования TIOBE. URL: https://tiobe.com/tiobe-index/
  2. SOLID принципы. Рефакторинг. URL: https://pro-prof.com/archives/1914
  3. Почему мне кажется, что студентов учат ООП неправильно. URL: https://habr.com/ru/post/345658/
  4. C++ Russia 2018: Фёдор Короткий, Память – идеальная абстракция. URL: https://vk.com/wall-105242702_701
  5. Мейер Б. Объектно-ориентированное конструирование программных систем. М.: Издательско-торговый дом «Русская Редакция», «Интернет-университет информационных технологий», 2005. 1232 с.: ил.
  6. Мартин Р. Чистый код. Создание, анализ и рефакторинг. Библиотека программиста. – СПб.: Питер, 2014. – 464 с.
  7. Джейсон Мак-Колм Смит Элементарные шаблоны проектирования : Пер. с англ. — М. : ООО “И.Д. Вильямс”, 2013. — 304 с.
  8. Диаграммы классов UML. URL: https://pro-prof.com/archives/3212
  9. Юнит-тестирование. Пример. Boost Unit Test. URL: https://pro-prof.com/archives/1549
  10. Э. Гамма Приемы объектно-ориентированного проектирования. Паттерны проектирования / Э. Гамма, Р. Хелм, Р. Джонсон, Д. Влиссидес. – СПб.: Питер, 2009. – 366 с.

Инкапсуляция

Цель инкапсуляции — улучшить качество взаимодействия вещей за счет их упрощения.

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

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

С точки зрения программирования, инкапсуляция — это «сокрытие реализации». Мне нравится такое определение. Наш класс может содержать сотни методов и реализовывать очень сложное поведение в различных ситуациях. Но мы можем скрыть от посторонних глаз все его методы (пометить модификатором private), а для взаимодействия с другими классами оставить всего пару-тройку методов (пометить их модификатором public). Тогда все остальные классы нашей программы будут видеть в этом классе всего три метода и вызывать именно их. А все сложности будут скрыты внутри класса, как кабина пилотов от счастливых пассажиров.

Инкапсуляция

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

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

class Animal {

private $name;

function __construct($name) {

$this->name = $name;

}

function getName() {

return $this->name;

}

}

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

История развития

Основа ООП была заложена в начале 1960-х годов. Прорыв в использовании экземпляров и объектов был достигнут в MIT с PDP-1, и первым языком программирования для работы с объектами стал Simula 67. Он был разработан Кристен Найгаард и Оле-Джохан Даль в Норвегии с целью создания симуляторов. Они работали над симуляциями взрыва кораблей и поняли, что могут сгруппировать корабли в различные категории. Каждому типу судна было решено присвоить свой собственный класс, который должен содержать в себе набор уникальных характеристик и данных. Таким образом, Simula не только ввела понятие класса, но и представила рабочую модель.

Термин «объектно-ориентированное программирование» был впервые использован Xerox PARC в языке программирования Smalltalk. Понятие ООП использовалось для обозначения процесса использования объектов в качестве основы для расчетов. Команда разработчиков была вдохновлена проектом Simula 67, но они спроектировали свой язык так, чтобы он был динамичным. В Smalltalk объекты могут быть изменены, созданы или удалены, что отличает его от статических систем, которые обычно используются. Этот язык программирования также был первым, использовавшим концепцию наследования. Именно эта особенность позволила Smalltalk превзойти как Simula 67, так и аналоговые системы программирования.

Simula 67 стала новаторской системой, которая впоследствии стала основой для создания большого количества других языков программирования, в том числе Pascal и Lisp. В 1980-х годах объектно-ориентированное программирование приобрело огромную популярность, и основным фактором в этом стало появление языка С++

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

Общие принципы модели стали применяться во многих современных языках программирования. Некоторые из них — Fortran, BASIC, Pascal. На тот момент многие программы не были разработаны с учетом ООП, что было причиной возникновения некоторых проблем совместимости. “Чистые” объектно-ориентированные языки программирования не обладали многими функциями, необходимыми программистам. Для решения этих проблем ряд исследователей предложили несколько новых языков программирования, созданных на основе принципов ООП с сохранением других, необходимых программистам, функций. Среди наиболее ярких примеров можно выделить Eiffel, Java, .NET. Даже в серьезных веб-разработках используются языки программирования, основанные на принципах ООП — PHP (у нас вы можете пройти курс ООП в PHP), Python, Ruby. По мнению экспертов, в ближайшие несколько десятилетий именно объектно-ориентированный подход будет оставаться основной парадигмой в развитии программирования.

Принцип подстановки Барбары Лисков (LSP)

Соответствует букве L акронима SOLID. Согласно этому принципу подтипы должны быть заменяемыми для супертипа. Другими словами, методы или функции, работающие с суперклассом, должны иметь возможность без проблем работать также и с его подклассами.

EPAM Data Quality Hiring Weeks

12–25 апреля, Онлайн, Беcплатно

tproger.ru

События и курсы на tproger.ru

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

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

Ниже приведён пример такого кода на Java:

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

Курс по теме SOLID Principles of Object-Oriented Design.

Абстракция в ООП на Java

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


// ОСНОВНАЯ АБСТРАКЦИЯ
// Мы можем использовать System.out.println(«Hello»), чтобы вывести строку на
// консоль и не заботиться о том, как работает метод println.
// АБСТРАКТНЫЕ КЛАССЫ
// Абстрактные классы содержат только объявление метода. Их назначение —
// выполнять роль суперклассов для других классов. Они не определяют, как
// методы реализуются, а только что они реализуют. Абстрактные классы не могут
// быть установлены, и подклассы ДОЛЖНЫ реализовать абстрактные методы.
abstract class FlyingAnimal {
public abstract void Fly();
}
class Bird extends FlyingAnimal {
protected String name;
protected int age;
Bird(String nm, int newAge) {
name = nm;
age = newAge;
}
@Override
public void Fly() {
System.out.println(«Flaps wings majestically.»);
}
}
// ИНТЕРФЕЙС
// Классы могут наследоваться только от одного суперкласса, но они могут
// реализовать несколько интерфейсов. Это расширяет возможности для применения
// абстракции. Классы, которые реализуют интерфейс, ДОЛЖНЫ реализовать
// методы в интерфейсе.
// Стандартные классы
class Animal {
private String name;
private int age;
public void identify() {
System.out.println(«I am an animal!»);
}
public void rename(String newName) {
name = newName;
}
public String getName() {
return name;
}
public void setAge(int newAge) {
if(newAge > 0)
age = newAge;
}
public int getAge() {
return age;
}
}
// Интерфейс для животных, которые могут летать. Нам нет дела до того,
// как они летают, просто они могут летать.
public interface ICanFly {
void Fly();
}

// Интерфейс для животных, которые могут плавать. Нам нет дела до того,
// как они плавают, просто они могут плавать.
public interface ICanSwim {
void Swim();
}
// Утка — это животное, которое может и летать, и плавать.
class Duck extends Animal implements ICanFly, ICanSwim {
public void Quack() {
System.out.println(«QUACK!»);
}
@Override
public void Identify() {
System.out.println(«I am a duck!»);
}
@Override
public void Fly() {
System.out.println(«Flaps wings majestically.»);
}
@Override
public void Swim() {
System.out.println(«Kicks feet.»);
}
}
// Рыба — это животное, которое умеет плавать

Обратите внимание на то, что
// реализация метода Swim отличается для утки и для рыбы.
class Fish extends Animal implements ICanSwim {
@Override
public void Identify() {
System.out.println(«I am a fish!»);
}
@Override
public void Swim() {
System.out.println(«Wiggles fish-body»);
}
}
// Самолет — это не животное, но он все равно может летать.
class AirPlane implements ICanFly {
protected String name;
protected int mileage;
@Override
public void Fly() {
System.out.println(«Turns propeller»);
}
}

Данная публикация является переводом статьи «Four Principles of Object-Oriented Programming with Examples in Java» , подготовленная редакцией проекта.

Создание новых объектов в JavaScript

JavaScript содержит набор встроенных объектов, но вы можете создавать свои объекты следующими способами:

  1. с помощью «конструктора» объекта new Object();
  2. с помощью фигурных скобок {…}с необязательным списком свойств (литеральная нотация). 

JavaScript

let nameObject = new Object() // синтаксис «конструктор объекта»

let nameObject = {}; // синтаксис «литерал объекта» или «литеральная нотация»

1
2
3

let nameObject=newObject()// синтаксис «конструктор объекта»

let nameObject={};// синтаксис «литерал объекта» или «литеральная нотация»

Обычно используют вариант с фигурными скобками {…}. Такое объявление называют литералом объекта (литеральной нотацией).

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

Таким образом, при использовании литерального синтаксиса {…} мы сразу можем:

  • сразу поместить в объект несколько свойств в виде пар «ключ: значение»;
  • создать пустой объект и добавить в него свойства позже.

Примеры

JavaScript

// Добавление свойств в объект при его создании

1
2
3
4
5
6
7
8
9
10
11
12
13
14

// Добавление свойств в объект при его создании
 

constuser={

firstName»Alex»,

lastName»NAV»,

Age»40″,

isAdmintrue,

email»email@email.ru»,

«user-adress»{// в кавычках, т.к. имя невалидное (через дефис)

country»Russia»,

sity»Moscow»

},

skills»html»,»css»,»JS»

};

JavaScript

// Создание пустого объекта и добавление в него свойств позже

let obj = {};
obj.name = «messi»;
obj.year = 2018;
obj.speak = function() {
return «My Name is » + this.name + «and this is year » + this.year;
};

1
2
3
4
5
6
7
8

// Создание пустого объекта и добавление в него свойств позже
 

let obj={};

obj.name=»messi»;

obj.year=2018;

obj.speak=function(){

return»My Name is «+this.name+»and this is year «+this.year;

};

Создание объекта с использованием метода Object.create()

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

JavaScript

// список свойств и методов для Animal
var Animal = {
type: «Invertebrates», // Значение type по умолчанию
displayType: function() {
// Метод отображающий тип объекта Animal
console.log(this.type);
}
};

// Создаем объект Animal
var animal1 = Object.create(Animal);
animal1.displayType(); // Invertebrates

// Создаем объект Animal и присваиваем ему type = Fishes
var fish = Object.create(Animal);
fish.type = «Fishes»;
fish.displayType(); // Fishes

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

// список свойств и методов для Animal

varAnimal={

type»Invertebrates»,// Значение type по умолчанию

displayTypefunction(){

// Метод отображающий тип объекта Animal

console.log(this.type);

}

};

 
// Создаем объект Animal

varanimal1=Object.create(Animal);

animal1.displayType();// Invertebrates

 
// Создаем объект Animal и присваиваем ему type = Fishes

varfish=Object.create(Animal);

fish.type=»Fishes»;

fish.displayType();// Fishes

Роль инкапсуляции

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

Т.е. инкапсуляция представляет собой способности языка скрывать излишние детали реализации от пользователя объекта.
Например, предположим, что используется класс по имени DatabaseReader, который
имеет два главных метода: Open() и Close().

Фиктивный класс DatabaseReader инкапсулирует внутренние детали нахождения,
загрузки, манипуляций и закрытия файла данных. Программистам нравится инкапсуляция, поскольку этот принцип ООП упрощает кодирование. Нет необходимости беспокоиться о многочисленных строках кода, которые работают «за кулисами», чтобы
реализовать функционирование класса DatabaseReader. Все, что потребуется — это
создать экземпляр и отправлять ему соответствующие сообщения (например, «открыть файл по имени AutoLot.mdf, расположенный на диске С:»).

С идеей инкапсуляции программной логики тесно связана идея защиты данных.
В идеале данные состояния объекта должны быть специфицированы с использованием ключевого слова private (или, возможно, protected). Таким образом, внешний мир
должен вежливо попросить, если захочет изменить или получить лежащее в основе значение. Это хороший принцип, поскольку общедоступные элементы данных можно легко повредить (даже нечаянно, а не преднамеренно).

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

Код и данные, составляющие вместе класс, называют членами. Данные, определяемые классом, называют полями, или переменными экземпляра. А код, оперирующий
данными, содержится в функциях-членах, самым типичным представителем которых
является метод. В C# метод служит в качестве аналога подпрограммы. (К числу других
функций-членов относятся свойства, события и конструкторы.) Таким образом, методы класса содержат код, воздействующий на поля, определяемые этим классом.

Ключевые преимущества

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

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

  • Простота. Программы, написанные с применением языков ООП, действительно легко понять. Поскольку все рассматривается как объекты, объектно-ориентированные языки позволяют смоделировать концепцию реального мира.
  • Высокая скорость разработки. Подход ООП предлагает возможность многократного использования классов. Вы можете повторно использовать уже созданные классы вместо того, чтобы записывать их снова. Кроме того, концепция ООП допускает параллельную разработку и использование нескольких классов. Больше усилий прилагается к объектно-ориентированному анализу и проектированию, что также снижает общие затраты на разработку ПО.
  • Удобство тестирования и обслуживания. Поскольку конструкция кода является модульной, часть системы может быть обновлена в случае возникновения проблем без необходимости внесения масштабных изменений. Существующий код легко поддерживать и менять, поскольку новые объекты могут создаваться с небольшими отличиями от существующих. Это делает объектно-ориентированное программирование легко расширяемым — новые функции или изменения в операционной среде могут быть легко внедрены на основе уже существующих.

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

@ivashkevich

18.09.2019 в 07:43

4069

+10

Принципы ООП

Главные принципы в ООП – абстрагирование, инкапсуляция, наследование и полиморфизм.

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

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

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

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

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *

Adblock
detector