Тверской государственный университет
Опубликован: 02.12.2009 | Доступ: свободный | Студентов: 2459 / 324 | Оценка: 4.47 / 4.24 | Длительность: 14:45:00
Лекция 5:

Отношения между классами. Клиенты и наследники

Абстрактные классы

С наследованием тесно связан еще один важный механизм проектирования семейства классов - механизм абстрактных классов. Начну с определений.

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

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

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

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

Абстрактный класс Stack

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

/// <summary>
    /// Абстрактный стек целых чисел
    /// С операциями: Put, Remove, Item, IsEmpty
    /// </summary>
    public abstract class Stack
    {        
        /// <summary>
        /// Втолкнуть элемент item  в стек
        /// </summary>
        /// <param name="item">Целое число</param>
        public abstract void Put(int item);

        /// <summary>
        /// Предусловие: Стек не пуст!
        /// Удалить элемент в вершине стека
        /// </summary>
        public abstract void Remove();

        /// <summary>
        /// Предусловие: Стек не пуст!
        /// Прочитать элемент в вершине стека
        /// </summary>
        public abstract int Item();

        /// <summary>
        /// Определить, пуст ли стек
        /// </summary>
        /// <returns>true, если пуст, иначе false</returns>
        public abstract bool IsEmpty();
    }

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

Класс ListStack - потомок абстрактного класса Stack

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

class Linkable
    {
        internal int info;
        internal Linkable next;
    }

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

Класс ListStack будет потомком абстрактного класса Stack и клиентом класса Linkable. Теперь, когда принято решение о представлении данных, основанное на списковой структуре, несложно определить реализацию абстрактных методов класса Stack. Вот как выглядит реализация класса ListStack:

public class ListStack : Stack
    {
        //поля
        Linkable top;
        //конструктор
        public ListStack()
        {
            top = new Linkable();
        }
        //Методы

        /// <summary>
        /// Втолкнуть элемент item  в стек
        /// </summary>
        /// <param name="item">Целое число</param>
        public override void Put(int item)
        {
            Linkable newitem = new Linkable();
            newitem.info = item;
            newitem.next = top;
            top = newitem;
        }
        /// <summary>
        /// Предусловие: Стек не пуст!
        /// Удалить элемент в вершине стека
        /// </summary>
        public override void Remove()
        {
             top = top.next;
        }
        /// <summary>
        /// Предусловие: Стек не пуст!
        /// Прочитать элемент в вершине стека
        /// </summary>
        public override int Item()
        {
            return (top.info);
        }
        /// <summary>
        /// Определить, пуст ли стек
        /// </summary>
        /// <returns>true, если пуст, иначе false</returns>
        public override bool IsEmpty()
        {
            return (top.next == null);
        }
   }

Класс имеет одно поле top класса Linkable и методы, наследованные от абстрактного класса Stack. Реализация операций традиционна для спискового представления данных и приводится без пояснений. Добавим в класс еще одну операцию, которая отсутствует у абстрактного класса и не принадлежит к операциям, традиционным для стека. Но для стека, основанного на списковом представлении, операция полезна, она преобразует стек в список.

public ArrayList list = new ArrayList();
        public ArrayList StackToList()
        {
            list.Clear();
            Linkable temp = top;
            while (temp.next != null)
            {
                list.Add(temp.info);
                temp = temp.next;
            }
            return list;
        }

Для тестирования работы построенного класса добавим в Windows-проект новую форму, реализующую пользовательский интерфейс. Интерфейсный класс, задающий форму, будет клиентом класса ListStack.

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

Работа со стеком

Рис. 4.8. Работа со стеком

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

public partial class FormStack : Form
    {
        ListStack stack;
        ArrayList list;
        const string NL = "\r\n";
        public FormStack()
        {
            InitializeComponent();
        }

        private void buttonCreate_Click(object sender, EventArgs e)
        {
            stack = new ListStack();
            list = new ArrayList();
            textBoxResult.Text = "Стек создан!";
            ShowStack();
        }
        void ShowStack()
        {
            list = stack.StackToList();
            listBoxStack.Items.Clear();
            foreach (int item in list)
                listBoxStack.Items.Add(item);
        }

        private void buttonPut_Click(object sender, EventArgs e)
        {
            if (stack == null)
            {
                textBoxResult.Text = "Создайте стек!";
                return;
            }
            int item = 0;
            try
            {
                item = int.Parse(textBoxItem.Text);
            }
            catch (Exception)
            {
                textBoxResult.Text =
                    "Некорректно задан элемент item!" +
                    NL + "Необходимо целое число!";
                return;
            }
            stack.Put(item);
            textBoxResult.Text =
                " Операция Put выполнена успешно!";
            ShowStack();
        }

        private void buttonRemove_Click(object sender, EventArgs e)
        {
            if (stack == null)
            {
                textBoxResult.Text = "Создайте стек!";
                return;
            }
            if (!stack.IsEmpty())
            {
                textBoxItem.Text = stack.Item().ToString();
                stack.Remove();
                textBoxResult.Text =
                    " Операция Remove выполнена успешно!";
                ShowStack();
            }
            else
                textBoxResult.Text =
                    "Стек пуст. Удаление невозможно!" +
                NL + " Операция Remove не выполнена!";
            
        }

        private void buttonItem_Click(object sender, EventArgs e)
        {
            if (stack == null)
            {
                textBoxResult.Text = "Создайте стек!";
                return;
            }
            if (!stack.IsEmpty())
            {
                int item = stack.Item();
                textBoxItem.Text = item.ToString();
                textBoxResult.Text =
                    " Операция Item выполнена успешно!";                
            }
            else
                textBoxResult.Text =
                    "Стек пуст. Чтение невозможно!" +
                NL + " Операция Item не выполнена!";
        }

        private void buttonIsEmpty_Click(object sender, EventArgs e)
        {
            if (stack == null)
            {
                textBoxResult.Text = "Создайте стек!";
                return;
            }
            if (stack.IsEmpty())
                textBoxResult.Text = "Стек пуст!";
            else
                textBoxResult.Text = "Стек не пуст!";
        }        
    }
Класс ArrayList - потомок абстрактного класса Stack

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

Массивы, в отличие от списка, имеют фиксированный размер. Конечно, размер массива можно передавать конструктору класса, позволяя строить стеки заданной емкости. Но в этом случае на емкость стека накладывается ограничение. Можно, конечно, использовать не массив C#, а встроенную динамическую структуру ArrayList, которая была задействована для представления списка. Но это не честно с методической точки зрения, поскольку в библиотеке FCL есть и класс Stack, собственную реализацию которого хочется построить. Еще одно возможное решение, которое предлагается реализовать, может быть основано на следующем подходе. Вначале строится массив фиксированного размера, что и определяет текущую емкость стека. Если в процессе работы со стеком обнаруживается, что нужно добавить в стек элемент, а памяти уже нет, то динамически увеличивается размер массива.

Федор Антонов
Федор Антонов

Здравствуйте!

Записался на ваш курс, но не понимаю как произвести оплату.

Надо ли писать заявление и, если да, то куда отправлять?

как я получу диплом о профессиональной переподготовке?

Илья Ардов
Илья Ардов

Добрый день!

Я записан на программу. Куда высылать договор и диплом?