Лекция 18 (лекции (2002))

Лекция 18

Часть II:

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

программирования (ООЯП)

Идут очень интенсивные споры по поводу того, что составляет предмет ОО проектирования.

У нас концепция: какие черты у ЯП, чтобы он мог называться ООЯП?

3 составляющие:

1. Инкапсуляция (для построения больших систем)

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

3. Динамический полиморфизм

Во многих ЯП существует статический полиморфизм: одной сущьности (подпрограмма) может соответствовать несколько форм (несколько тел). Это overloading (перегрузка). Связывание (тела функции с её вызовом) происходит в момент компиляции. Хотя одной сущности может соответствовать несколько тел (одному имени- несколько функций). Динамический полиморфизм должен быть в ООЯП (без него наследование особого смысла не имеет).

[Книга Себесты] ЯП должны поддерживать концепции:

АТД

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

динамическое связывание

• то же самое, но другими словами

Про инкапсуляцию поговорили в первой части нашего курса.

Наследование уже пояляется в традиционных ЯП. Понятие наследования есть в Аде:

package M is

type T is /* набор операций */

procedure P(x: inout T);

...

end M;

Соответствующий пакет называется определяющим для ТД.

Где-то можем отдельно компилированную единицу определить:

with M; use M;

Написать свой модуль-пакет:

package MM is

type T1 is new T;

{можем ввести свой новый ТД. Здесь может стоять какое-то уточнение, если тип данных Т был описан в виде какой-то структуры, или, например, неограниченный массив; но чаще в Т идёт речь о каком-то приватном ТД (так что никакого уточнения структуры быть не может), но что известно, что ТД Т1 обладает тем же набором операций, что и Т. Единственное, что здесь мы можем добавлять свои новые операции:}

procedure PP(x : T1);

{можем написать что-то ещё или можем переопределить процедуру P}

procedure P(x: inout T);

То есть какое-то наследование есть. Но тут идёт речь именно о наследовании множества операций. Происходит полное наследование структуры и полное наследование множества операций. Операции при наследовании можем добавлять или переопределять, но структуру типа Т1, по сравнению с типом Т мы поменять не можем. Это вырожденнный случай наследования.

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

Глава 1: наследование

Общая идея наследования: у нас есть некий базовый ТД, который называется базовым классом (суперкласс в терминологии языка SmallTalk). К тому же, у нас есть некий механизм наследования, который из базового типа Т выводит Т1; где Т- это базовый класс или суперкласс(в Java вызов метода суперкласса- ключевое слово super) , а Т1- это производный класс (такую терминологию ввёл Страуструб в языке С++) или подкласс. При этом Т1 содержит все члены (и члены-данные и члены-функции) Т, но добавляет ещё новые члены, поэтому Страуструпу не понравилось слово «подкласс», так как «под»- это что-то меньшее. А тут ситуация немножко наоборот: производный класс расширяет. При наследовании синтаксис может быть разный, но суть одна.

Оберон (самый простой ООЯП): базовым классом может быть любой класс- запись.

Две категории ЯП:

1)Есть специальные ТД, которые можно расширять

2)Единственный ТД можно расширять

TYPE T = RECORD

X: INTEGER

END;

T1 = RECORD (T)

Y: INTEGER

END;

A: T; B: T1;

Можно писать:

A.X

B.X, B.Y

Можно расширять любой ТД, типа запись.

Delphi:

class T;

type T1 =

class (T)

...

end;

В Delphi, с точки зрения расширения, подход несколько иной. Для обеспечения совместимости со старыми языками (Турбо Паскаль): расширять можно только класс (обычные записи расширять нельзя). То есть, просто со времён Турбо Паскаля 5.5 была добавлена новая совокупность типов данных (Турбо Паскаль- ключевое слово object, Delphi- class). В Delphi есть базовый выделенный класс (Тobject). Если мы пишем:

type X =

class

...

end;

Это аналогично:

type X =

class (T: Object)

...

end;

{из терминологии языка SmallTalk}

В Delphi - это TObject, в Java - Object, С# - object. Это специальный класс, про который компилятор кое-что знает: в частности, то, что любой другой класс, даже, если не указано наследование, он всегда, по умолчанию будет выводиться, из этого базисного класса. В Обероне отсутствует понятие базисного ТД, на зато можно расширять произвольный ТД типа запись. В Java и С# нет понятия запись, зато есть понятие структура в C#, которая кроме отсутствия ссылочной семантики отличается от класса, именно тем, что от неё ничего нельзя наследовать, но, опять же, по умолчанию, ТД структура наследуется от object и по этому обладает всеми свойствами. Базисный ТД обладает только функциями(интерфейсом), но не данными.

В языках, которые объектную ориентированность добавляли к уже существующим процедурным парадигмам,- C++ и Ада 95, которые тоже являются настоящими ООЯП, необходимы были дополнительные средства, сопряженные с существующей концепцией типа. Поэтому там не существует никакого супербазисного ТД, из которого выводятся все остальные.

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

сlass X {

...

};

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

class Y: базовый класс { /* дополнительные члены */ };

При этом сложность в том, что описание базового класса выглядит так: [модификатор доступа] имя класса. И из стандартных ТД наследовать нельзя. Но во многих библиотеках существует базовый класс, принадлежащий библиотеке, а не языку, из которого всё и выводится (В Борландовских библиотеках- это TObject), так как наличие базового супер класса является преимуществом. Модификатор доступа может отсутсвовать, по умолчанию: если у нас ключевое слово class, то это private, если structure- public. При этом есть ещё и protected: он управляет доступом к членам базовых классов с точки зрения производных классов. Эти модификаторы в применении к наследованию- это модификация правил доступа в базовом классе:

class X {

public:

int i;

protected:

int j;

private

int k;

}

class Y: public X {

void f() {

i = 0;

j = 1;

k = 2; - нельзя

};

}

Если модификатор public, то какие права доступа объявлены в классе Х, такими они и сохраняются в классе Y. И если где-то есть функция g():

void g() {X a; Y: b;

можно писать:

a.i, b.i,

нельзя писать:

a.j, a.k, b.j, b.k

}

Е сли class Y: protected X, то публичные члены становятся защищёнными, защищённые остаются защищёнными, а приватные остаются приватными. Модификатор может только понизить права доступа к соответствующему классу. Следовательно теперь обращение b.i становится некорректным.

Если class Y: private X, то даже защищённые члены Х становятся приватными. То есть, хотя мы в классе Y имели право обращаться к j:

class Z: public Y

j = 1;

Аналогичным образом работает концепция друзей:

class X {

friend class T;

...

}

void T::g() {X x; Y y;

x.k- можно; y.k- нельзя (Y не разрешил дружбу с Т). То есть для продолжения отношений класс Y должен явно объявить дружбу с T. Дружба не транзитивна.

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

Другие ЯП отказались от таких изощрённых средств управления доступом.

Ада: есть понятие тегированной (помеченной) записи:

type T is tagged record

...

end;

• из помеченной записи можно наследовать:

type T1 is new T with record

...

end;

новое при наследовании (уточняющая часть)

Так как в Аде, как и в Обероне, все функции и процедуры ещё не считаются членами класса, то Т1 полностью наследует все операции (операции доступа к самой записи, плюс операции, описанные в том же пакете, что и тип данных Т).

Приватные ТД:

type T is tagged private;

следовательно внизу должно быть:

private

type T is record ... end;

end;

Можно расширять(в том числе и приватныеТД) с помощью конструктора new, после которого стоит ТД. А если хотим изменить только набор операций- специальная конструкция:

type T1 is new T

with null record;

Почему так надо писать? Что никаких членов не добавляем.

type T1 is new T;

Но в чём принципиальная разница этой и предыдущей конструкции? Нарушается первая, самая главная, аксиома концепции уникальности типов (каждый объект данных имеет тип и этот ТД единственный). ООЯП нарушают её тем, что если есть наследование и из Т наследуем Т1, то объекты Т1 одновременно являются и объектами типа Т: Т Т1 (появляется отношение наследования, которое уместно обозначать, как отношение включения). Но аксиома №4: различные ТД не совместимы по операциям. Следствие:

procedure P(x: T);

её фактический параметр может быть типа объект Т1. И это относится к любой операции, в том числе, и операции присваивания.

Итак, если Т => Т1 (из Т выводим Т1)

1) a b

a = b; - корректно

P(a), P(b) /* тут Т := Т1 */ - можно

но нельзя:

b = a;

procedure P1(x: T1);

P1(b);

P1(a); { T1 := T }

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

b = a;- b не является полностью определённой переменной, следовательно это присваивание (и такая передача параметров) некорректно.

2)В языках, где есть указатели и ссылки, которые являются базовыми ТД, и, вроде бы никакого наследования относительной базовых ТД вводится не может, а наследуются у нас в языках либо классы, либо их аналогии (структуры или записи). Но для ссылок и указателей приняты те же правила. Если P => P1, то мы считаем, что у нас для ссылок и указателей имеет место точно такое же наследование(хотя с точки зрения реализации и указатели и ссылки- это просто адреса памяти) в смысле, что к ним применимы теже самые правила в смысле присваивания:

PT => PT1

pa pb

pa = pb; - разрешено

p b = pa; - запрещено

Ещё замечание о распределении памяти: то есть каким образом выглядит объект. Речь всегда идёт о некой структуре данных, то есть о последовательносте полей. То с точки зрения распределения памяти, у нас, в принцыпе, есть два способа реализации наследования:

1)Линейное распределение памяти