Объектно-ориентированное программирование, или более известное как ООП, является одним из основных столпов Java, который использует его мощность и простоту использования. Чтобы стать профессиональным Java-разработчиком, вы должны получить безупречный контроль над различными концепциями Java OOP, такими как наследование, абстракция, инкапсуляция и полиморфизм. В рамках этой статьи я дам вам полное представление об одной из самых важных концепций ООП, то есть наследовании в Java, и о том, как это достигается.
Ниже приведены темы, которые я буду обсуждать в этой статье:
- Введение в наследование в Java
- Типы наследования в Java
- Одиночное наследование
- Многоуровневое наследование
- Иерархическое наследование
- Гибридное наследование
- Правила наследования в Java
Введение в наследование в Java
В ООП компьютерные программы разрабатываются таким образом, что все является объектом, взаимодействующим друг с другом. Наследование - это неотъемлемая часть ООП Java, позволяющая наследовать свойства одного класса другим. По сути, это помогает повторно использовать код и устанавливать отношения между разными классами.
Как известно, ребенок наследует свойства своих родителей. Похожая концепция используется в Java, где у нас есть два класса:
1. Родительский класс (Супер или Базовый класс)
2. Дочерний класс (подкласс или производный класс)
Класс, наследующий свойства, известен как дочерний класс, тогда как класс, свойства которого наследуются, известен как родительский класс.
Синтаксис:
Теперь, чтобы наследовать класс, нам нужно использовать ключевое слово extends. В приведенном ниже примере класс Son является дочерним классом, а класс Mom - родительским классом. Класс Son наследует свойства и методы класса Mom.
class Son extends Mom
{
//your code
}
Давайте посмотрим небольшую программу и разберемся, как она работает. В этом примере у нас есть базовый класс Teacher и подкласс HadoopTeacher. Поскольку класс HadoopTeacher расширяет свойства базового класса, нам не нужно объявлять эти свойства и метод в подклассе.
class Teacher{
String designation = "Teacher";
String collegeName = "Edureka";
void does(){
System.out.println("Teaching");
}
}
public class HadoopTeacher extends Teacher{
String mainSubject = "Spark";
public static void main(String args[]){
HadoopTeacher obj = new HadoopTeacher();
System.out.println(obj.collegeName);
System.out.println(obj.designation);
System.out.println(obj.mainSubject);
obj.does();
}
}
Вывод:
Эдурека
Учитель
Искра
Обучение
Теперь давайте перейдем к рассмотрению различных типов наследования, поддерживаемых Java.
Типы наследования в Java
На рисунке ниже изображены типы наследования:
Одиночное наследование
При одиночном наследовании один класс наследует свойства другого. Это позволяет производному классу наследовать свойства и поведение от единственного родительского класса. Это, в свою очередь, позволит повторно использовать код, а также добавит новые функции в существующий код.
Здесь Class A - это ваш родительский класс, а Class B - ваш дочерний класс, который наследует свойства и поведение родительского класса. Аналогичная концепция представлена в приведенном ниже коде:
class Animal{
void eat(){System.out.println(“eating”);}
}
class Dog extends Animal{
void bark(){System.out.println(“barking”);}
}
class TestInheritance{
public static void main(String args[]){
Dog d=new Dog();
d.bark();
d.eat();
}
}
Многоуровневое наследование
Когда класс является производным от класса, который также является производным от другого класса, то есть класса, имеющего более одного родительского класса, но на разных уровнях, такой тип наследования называется многоуровневым наследованием.
Если мы говорим о блок-схеме, класс B наследует свойства и поведение класса A, а класс C наследует свойства класса B. Здесь A - родительский класс для B, а класс B - родительский класс для C. Итак, в этом случае class C неявно наследует свойства и методы класса A вместе с классом B. Вот что такое многоуровневое наследование.
class Animal{
void eat(){System.out.println(“eating…”);}
}
class Dog extends Animal{
void bark(){System.out.println(“barking…”);}
}
class Puppy extends Dog{
void weep(){System.out.println(“weeping…”);}
}
class TestInheritance2{
public static void main(String args[]){
Puppy d=new Puppy();
d.weep();
d.bark();
d.eat();
}
}
Иерархическое наследование
Когда у класса есть несколько дочерних классов (подклассов) или, другими словами, несколько дочерних классов имеют один и тот же родительский класс, тогда такой вид наследования называется иерархическим.
На приведенной выше блок-схеме классы B и C являются дочерними классами, которые наследуются от родительского класса, то есть класса A.
class Animal{
void eat(){System.out.println(“eating…”);}
}
class Dog extends Animal{
void bark(){System.out.println(“barking…”);}
}
class Cat extends Animal{
void meow(){System.out.println(“meowing…”);}
}
class TestInheritance3{
public static void main(String args[]){
Cat c=new Cat();
c.meow();
c.eat();
}
}
Гибридное наследование
Гибридное наследование - это комбинация двух или более типов наследования.
Теперь, когда мы знаем, что такое наследование и его различные типы, давайте продвинемся дальше и рассмотрим некоторые важные правила, которые следует учитывать при наследовании классов.
Правила наследования в Java
ПРАВИЛО 1. Множественное наследование НЕ разрешено в Java.
Множественное наследование относится к процессу, в котором один дочерний класс пытается расширить более одного родительского класса. На приведенной выше иллюстрации класс A является родительским классом для классов B и C, которые дополнительно расширяются классом D. Это приводит к проблеме Diamond. Почему? Допустим, у вас есть метод show () в классах B и C, но с разными функциями. Когда класс D расширяет классы B и C, он автоматически наследует характеристики B и C, включая метод show (). Теперь, когда вы пытаетесь вызвать show () класса B, компилятор не понимает, какой метод show () следует вызывать (из класса B или класса C). Следовательно, это приводит к двусмысленности.
Например:
class Demo1
{
//code here
}
class Demo2
{
//code here
}
class Demo3 extends Demo1, Demo2
{
//code here
}
class Launch
{
public static void main(String args[])
{
//code here
}
}
В приведенном выше коде Demo3 является дочерним классом, который пытается наследовать два родительских класса Demo1 и Demo2. Это недопустимо, так как приводит к проблеме с алмазом и неоднозначности.
ПРИМЕЧАНИЕ. Множественное наследование не поддерживается в Java, но вы все равно можете добиться его с помощью интерфейсов.
ПРАВИЛО 2: Циклическое наследование НЕ разрешено в Java.
Это тип наследования, при котором класс расширяется и сам образует цикл. А теперь подумайте, если класс расширяется сам по себе или каким-либо образом, если он образует цикл внутри определяемых пользователем классов, то есть ли шанс расширить класс Object. По этой причине это запрещено в Java.
Например:
class Demo1 extends Demo2
{
//code here
}
class Demo2 extends Demo1
{
//code here
}
В приведенном выше коде оба класса пытаются наследовать символы друг друга, что недопустимо, так как это приводит к двусмысленности.
ПРАВИЛО 3: Частные члены НЕ передаются по наследству.
Например:
class You
{
private int an;
private int pw;
You{
an =111;
pw= 222;
}
}
class Friend extends You
{
void change Data()
{
an =8888;
pw=9999;
}
}
void disp()
{
System.out.println(an);
System.out.println(pw);
}
}
class Launch
{
public static void main(String args[])
{
Friend f = new Friend();
f.change.Data();
f.disp();
}
}
Угадайте, что произойдет, когда вы выполните приведенный выше код. Как вы думаете, будут ли унаследованы частные переменные an и pw? Точно нет. Это остается неизменным, потому что они относятся к конкретному классу.
ПРАВИЛО 4: Конструкторы не могут быть унаследованы в Java.
Конструктор не может быть унаследован, так как подклассы всегда имеют разные имена.
class A {
A();}
class B extends A{
B();}
Вы можете делать только:
B b = new B(); // and not new A()
Вместо этого методы наследуются с «тем же именем» и могут использоваться. Однако вы все равно можете использовать конструкторы из A внутри реализации B:
classB extendsA{ B() { super(); } }
ПРАВИЛО 5: В Java мы назначаем родительскую ссылку дочерним объектам.
Родитель - это ссылка на объект, который является подтипом родительского объекта, то есть дочерним объектом. Почему это используется? Короче говоря, это предотвращает тесную связь вашего кода с одним классом. Поскольку ссылка относится к родительскому классу, она может содержать любой объект своего дочернего класса, то есть может ссылаться на любой из своих дочерних классов.
Он имеет следующие преимущества: -
- Диспетчеризация динамических методов позволяет Java поддерживать переопределение метода, которое является центральным для полиморфизма времени выполнения.
- Он позволяет классу определять методы, которые будут общими для всех его производных, в то же время позволяя подклассам определять конкретную реализацию некоторых или всех этих методов.
- Он также позволяет подклассам добавлять свои конкретные методы, подклассы для определения конкретной реализации некоторых из них.
Представьте, что вы добавляете getEmployeeDetails к классу Parent, как показано в приведенном ниже коде:
public String getEmployeeDetails() {
return "Name: " + name;
}
Мы могли бы переопределить этот метод в Child, чтобы предоставить более подробную информацию.
@Override
public String getEmployeeDetails() {
return "Name: " + name + " Salary: " + salary;
}
Теперь вы можете написать одну строку кода, которая получает все доступные сведения, независимо от того, является ли объект родительским или дочерним, например:
parent.getEmployeeDetails();
Затем проверьте следующий код:
Parent parent = new Parent();
parent.name = 1;
Child child = new Child();
child.name = 2;
child.salary = 2000;
Parent[] employees = new Parent[] { parent, child };
for (Parent employee : employees) {
employee.getEmployeeDetails();
}
Это приведет к следующему выводу:
Name: 1 Name: 2 Salary: 2000
Здесь мы использовали дочерний класс в качестве ссылки на родительский класс. У него было особое поведение, уникальное для класса Child, но если мы вызовем getEmployeeDetails (), мы сможем игнорировать разницу в функциональности и сосредоточиться на том, насколько похожи классы Parent и Child.
ПРАВИЛО 6: Конструкторы выполняются из-за присутствия в конструкторе super ().
Как вы уже знаете, конструкторы не наследуются, но они выполняются из-за ключевого слова super (). «Super ()» используется для обозначения расширенного класса. По умолчанию он будет относиться к классу Object. Конструктор в Object ничего не делает. Если конструктор явно не вызывает конструктор суперкласса, то компилятор Java вставляет вызов конструктору суперкласса без аргументов по умолчанию.
На этом мы подошли к концу статьи «Наследование в Java». Надеюсь, вы нашли его информативным и помогли повысить ценность ваших знаний.
Если вы хотите ознакомиться с другими статьями о самых популярных технологиях на рынке, таких как искусственный интеллект, DevOps, этический взлом, посетите официальный сайт Edureka.
Обязательно обратите внимание на другие статьи в этой серии, которые объясняют различные другие аспекты Java.
5. Строка Java
6. Java Array
8. Java Threads
17. Comparable in Java.
26. Деревья на Яве.
30. 55 самых популярных вопросов на собеседовании с сервлетами
36. 50 лучших вопросов для собеседований по коллекциям Java, которые вам нужно знать
40. Лучшие вопросы и ответы на собеседовании по MVC, которые вам нужно знать
42. Тупик в Java.
46. Деструктор на Яве.
Первоначально опубликовано на www.edureka.co 20 декабря 2018 г.
