Оглавление
Как работает наследование в C#
- Единое наследство
- Многоуровневое наследование
- Иерархическое наследование
- Множественное наследование (не поддерживается в C#)
Что такое наследование в C#
В C#, использующем наследование, один класс может принимать или наследовать свойства и методы другого класса. Другими словами, он позволяет создавать новый класс на основе существующего класса, известного как базовый класс или суперкласс. Класс, образованный после взятия свойств базового класса, называется производный класс или подкласс.
Этот производный класс в C# не только принимает свойства базового класса, но также может добавлять собственные уникальные функции.
Как работает наследование в C#
В C# наследование достигается за счет использования двоеточия. (:) символ. Имя базового класса определяется после двоеточия и определяется производным классом.
Ниже приведен синтаксис для создания производного класса, который принимает свойства базового класса:
класс DerivedClass : Базовый класс{
// члены производного класса
}
Вот в этом коде производный класс имя производного класса, а Базовый класс это имя базового класса. : указывает, что DerivedClass наследуется от BaseClass. Члены DerivedClass могут получить доступ к членам BaseClass, если они не являются частными.
Типы наследования в C#
C# поддерживает четыре типа наследования: одиночное, многоуровневое, иерархическое и множественное наследование. Рассмотрим каждый тип.
Единое наследство
Одиночное наследование — наиболее распространенный тип наследования, при котором производный класс принимает или наследует свойства только одного базового класса.
Например, данный код объясняет иерархию классов и демонстрирует концепции наследования.
используя систему ;используя систему ;
Класс Автомобиль
{
общественный пустота Начинать ( )
{
Консоль. WriteLine ( 'Машина завелась' ) ;
}
}
класс Тесла : Машина
{
общественный пустота Ускорить ( )
{
Консоль. WriteLine ( «Тесла разгоняется» ) ;
}
}
программа класса
{
статический пустота Основной ( нить [ ] аргументы )
{
Тесла моя Тесла '=' новая Тесла ( ) ;
моя Тесла. Начинать ( ) ; // Вывод: Машина завелась
моя Тесла. Ускорить ( ) ; // Вывод: Тесла ускоряется
}
}
В приведенном выше коде Класс автомобиля является базовым классом и имеет метод, называемый Начинать() , который просто печатает сообщение Автомобиль запущен к консоли.
Тесла класс является производным от класса Car и принимает все свойства класса Car. Класс Tesla добавляет метод с именем Ускорить() , который печатает сообщение Тесла ускоряется к консоли.
Основной() функция определяет экземпляр класса Tesla с именем моя Тесла и вызывает его методы Start() и Accelerate().
Многоуровневое наследование
Многоуровневое наследование — это когда производный класс наследуется от другого производного класса, который, в свою очередь, наследуется от базового класса.
Например, следующий код C# демонстрирует наследование и переопределение методов в иерархии классов.
используя систему ;класс Животное
{
общественный пустота Есть ( )
{
Консоль. WriteLine ( «Поедание животных» ) ;
}
}
класс млекопитающих : Животное
{
общественный пустота Бегать ( )
{
Консоль. WriteLine ( «Бег млекопитающих» ) ;
}
}
класс Собака : Млекопитающее
{
общественный пустота Лаять ( )
{
Консоль. WriteLine ( 'Собачий лай' ) ;
}
}
программа класса
{
статический пустота Основной ( нить [ ] аргументы )
{
Моя собака '=' новая собака ( ) ;
моя собака. Есть ( ) ; // Вывод: поедание животных
моя собака. Бегать ( ) ; // Вывод: бегущее млекопитающее
моя собака. Лаять ( ) ; // Вывод: лай собаки
}
}
Здесь Собака является производным классом, который наследуется от Млекопитающее , который, в свою очередь, наследуется от Животное . Класс Dog имеет доступ ко всем свойствам, методам и поведению Mammal и Animal, а также может определять свой собственный уникальный метод. Лаять() .
Класс животных является базовым классом и имеет метод, называемый Есть() , который просто выводит на консоль сообщение «Животное ест».
Класс млекопитающих является производным от класса Animal и добавляет метод с именем Бегать() , который выводит сообщение Mammal running на консоль.
Класс собак является производным от класса Mammal и добавляет метод с именем Лаять() , который выводит на консоль сообщение Dog barking.
Метод Main() создает экземпляр класса Dog с именем моя собака и вызывает его методы Eat(), Run() и Bark().
Обратите внимание, что методы Eat() и Run() не определены в классе Dog, а наследуются от его родительских классов. Животное и Млекопитающее , соответственно. Лаять() метод определен только в классе Dog.
Иерархическое наследование
При иерархическом наследовании разное количество производных классов наследуются только от одного базового класса. Например:
используя систему ;форма класса
{
публичный пустота Рисовать ( )
{
Консоль. WriteLine ( «Рисунок формы» ) ;
}
}
класс Круг : Форма
{
публичный пустота Наполнять ( )
{
Консоль. WriteLine ( «Наполняющий круг» ) ;
}
}
класс Площадь : Форма
{
публичный пустота Цвет ( )
{
Консоль. WriteLine ( «Раскрасочный квадрат» ) ;
}
}
программа класса
{
статический пустота Основной ( нить [ ] аргументы )
{
Круг мойКруг '=' новый круг ( ) ;
мойкруг. Рисовать ( ) ; // Вывод: фигура чертежа
мойкруг. Наполнять ( ) ; // Вывод: Заполнение круга
Квадрат mySquare '=' новая площадь ( ) ;
моя площадь. Рисовать ( ) ; // Вывод: фигура чертежа
моя площадь. Цвет ( ) ; // Вывод: раскрашивание квадрата
}
}
В приведенном выше коде оба Круг и Квадрат являются производными классами, которые наследуются от Форма . Они имеют доступ к методу Draw(), определенному в Shape, а также могут определять свои собственные уникальные методы Fill() и Color().
Здесь мы создали объект класса Circle с именем мойкруг и объект Квадрат класс с именем мой квадрат . Затем мы вызываем Рисовать() метод, унаследованный от класса Shape, для обоих объектов.
Далее мы вызываем Наполнять() метод в myCircle, специфичный для класса Circle, и метод Цвет() метод в mySquare, специфичный для класса Square.
Вывод будет напечатан на консоли, как показано ниже:
Множественное наследование
Множественное наследование — это когда производный класс наследуется от нескольких базовых классов. Однако C# не поддерживает множественное наследование. Для достижения аналогичной функциональности C# использует интерфейсы .
Заключение
Наследование в C# позволяет классам наследовать поведение и функциональные возможности базовых классов. Используя наследование, мы можем повторно использовать код и создать иерархический поток внутри программы. Понимая различные типы наследования, можно писать более эффективный и организованный код, который легче поддерживать и расширять.