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

Скачать исходники для статьи можно ниже

Затем этот класс может наследоваться другими, более специализированными, классами, каждый из которых будет добавлять свои уникальные характеристики.
В терминологии Java наследуемый класс называют суперклассом. Наследующий класс носит название подкласса. Следовательно, подкласс — это специализированная версия суперкласса. Он наследует все члены, определенные суперклассом, и добавляет собственные, уникальные, элементы.

Основы наследования.

Чтобы наследовать класс, достаточно просто вставить определение одного
класса в другой с использованием ключевого слова extends.

В качестве иллюстрации рассмотрим короткий пример. Следующая программа создает суперкласс А и подкласс В. Обратите внимание на использование ключевого слова extends для создания подкласса класса А.

// Простой пример наследования.
// Создание суперкласса,
class А {
   int i, j;
   void showij() {
      System.out.println("i и j: " + i + " " + j);
   }
}

// Создание подкласса за счет расширения класса А.
class В extends А{
   int к;
   void showk(){
      System.out.println("к: " + к);
   }
   void sum(){
      System.out.println("i + j + k: " + (i + j + k));
   }
}


class Simplelnheritance {
   public static void main(String args[]) {
      A superOb = new A();
      В subOb = new В();
      // Суперкласс может использоваться самостоятельно.
      superOb.i = 10;
      superOb.j = 20;
      System.out.println("Содержимое superOb: ");
      superOb.showij();
      System.out.println();
      // Подкласс имеет доступ ко всем открытым членам
      // своего суперкласса. 
      subOb.i = 7;
      subOb.j = 8;
      subOb.k = 9;
      System.out.println("Содержимое subOb: ");
      subOb.showij();
      subOb.showk();
      System.out.println();
      System.out.println("Сумма i, j и k в subOb:");
      subOb.sum();
   }
}

Эта программа создает следующий вывод:

Содержимое superOb:
i и j: 10 20
Содержимое subOb:
i и j : 7 8
k: 9
Сумма i, j и k в subOb:
i+j+k: 24

Как видите, подкласс В включает в себя все члены своего суперкласса А. Именно поэтому объект subOb имеет доступ к переменным i и j и может вызывать метод showij().
Кроме того, внутри метода sum() возможна непосредственная ссылка
на переменные i и j, как если бы они были частью класса В.

Несмотря на то, что А — суперкласс класса В, он также является полностью независимым, самостоятельным классом. То, что класс является суперклассом подкласса, не означает невозможность его самостоятельного использования. Более того, подкласс может быть суперклассом другого подкласса.

Общая форма объявления класса, который наследуется от суперкласса, следующая.

class имя_подкласса extends имя_суперкласса {
// тело класса
}

Для каждого создаваемого подкласса можно указывать только один суперкласс.
Язык Java не поддерживает наследование нескольких суперклассов в одном
подклассе. Как было сказано, можно создать иерархию наследования, в которой подкласс становится суперклассом другого подкласса. Однако никакой класс не может быть собственным суперклассом.

Хотя подкласс включает в себя все члены своего суперкласса, он не может получать доступ к тем членам суперкласса, которые объявлены как private.
Например, рассмотрим следующую простую иерархию классов.

/* В иерархии классов закрытые члены остаются закрытыми
для своего класса.
Эта программа содержит ошибку, и ее компиляция
будет невозможна.
*/
// Создание суперкласса,
class А{
   int i; // открытая по умолчанию
   private int j; // закрыта, только для А
   void setij(int х, int у){
      i = х;
      j = у;
   }
}

// Переменная j класса А в этом классе недоступна,
class В extends А{
   int total;
   void sum(){
      total = i + j; // ОШИБКА, j в этом классе недоступна
   }
}

class Access{
   public static void main(String args[]){
      В subOb = new В();
      subOb.setij(10, 12);
      subOb.sum();
      System.out.println("Сумма равна " + subOb.total);
   }
}

Компиляция этой программы будет невозможна, поскольку использование переменной j внутри метода sum() класса В приводит к нарушению правил доступа.
Поскольку переменная j объявлена как private, она доступна только другим членам ее собственного класса. Подкласс не имеет к ней доступа.

Рассмотрим еще один пример, который поможет проиллюстрировать
возможности наследования.

// В этой программе наследование используется для расширения класса Box.
class Box{
   double width;
   double height;
   double depth;
   // вычисление и возврат объема
   double volume(){
      return width * height * depth;
   }
}

// Расширение класса Box включением в него веса,
class BoxWeight extends Box {
   double weight; // вес параллелепипеда
   // конструктор BoxWeight
   BoxWeight(double w, double h, double d, double m) {
      width = w;
      height = h;
      depth = d;
      weight = m;
   }
}
class DemoBoxWeight {
   public static void main(String args[]) {
      BoxWeight myboxl = new BoxWeight(10, 20, 15, 34.3);
      BoxWeight mybox2 = new BoxWeight(2, 3, 4, 0.076);
      double vol;
      vol = myboxl.volume();
      System.out.println("Объем myboxl равен " + vol);
      System.out.println("Вес myboxl равен " + myboxl.weight);
      vol = mybox2.volume();
      System.out.println("Объем mybox2 равен " + vol);
      System.out.println("Bec mybox2 равен " + mybox2.weight);
   }
}

Эта программа создает следующий вывод:
Объем myboxl равен 3000.0
Вес myboxl равен 34.3
Объем mybox2 равен 24.0
Bee mybox2 равен 0.076

Класс BoxWeight наследует все характеристики класса Box и добавляет к ним компонент weight.
Классу BoxWeight не нужно воссоздавать все характеристики класса Box. Он может просто расширять класс Box в соответствии с конкретными
целями.

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

Например, следующий класс наследует характеристики класса Box и добавляет атрибут цвета.

// Этот код расширяет класс Box, включая в него атрибут цвета,
class ColorBox extends Box {
   int color; // цвет параллелепипеда
   ColorBox(double w, double h, double d, int c) {
      width = w;
      height = h;
      depth = d;
      color = c;
   }
}

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