Наследование в Java: основные правила с примерами
Наследование в Java — механизм, который позволяет одному классу получить все элементы и свойства другого класса. Этот процесс также называют расширением, преобразованием или отношением «родитель-потомок».
Основные обозначения:
Суперкласс (родитель) — основной класс, от которого принимаются все элементы.
Подкласс (расширенный, дочерний) — класс, который преобразовывается от другого класса, при этом может иметь свои элементы.
Зачем применяют наследование в Java? Суть в том, что можно образовать новые классы, используя уже имеющийся код. При этом есть возможность добавить другие переменные в дочерний класс, получив при этом новый.
Синтаксис:
class Имя-подкласса extends Имя-суперкласса
{
// свойства и элементы
}
Ключевое слово extends означает, что создается новый класс от уже имеющегося.
class Fruit {
// поля и элементы
}
// применяем расширение
class Apple extends Fruit {
// свойства и элементы Fruit
// свойства и элементы Apple
}
Из примера видно, что класс Apple создается из Fruit, при этом наследуются все его элементы. Так, Fruit — это класс-родитель, а Apple — класс-потомок.
Как наследовать?
Основной и дочерний класcы создают определенную иерархию. На вершине — всегда базовый, а под ним строятся подклассы. При этом преобразованный класс служит родителем для других подклассов.
В Java существуют такие способы преобразования:
- одиночное;
- многоуровневое;
- иерархическое.
Рассмотрим их по порядку.
Одиночное наследование
Механизм одиночного наследования очень прост: подкласс получает свойства только от одного основного класса:
class Pet{
public void walk (){System.out.println("I will walk");}
class Cow extends Pet{
public void moo (){System.out.println("I will moo");}
}
Результат:
I will walk I will moo
Многоуровневое наследование
Многоуровневый процесс происходит при наследовании дополнительного класса от базового, затем этот же класс действует уже как основной для следующего:
class Pet{
public void walk (){System.out.println("I will walk.");}
}
class Cat extends Pet{
public void sleep (){System.out.println("I will sleep ");}
}
class Kitty extends Cat{
public void purr (){System.out.println("I will purr");}
}
class TestIn {
public static void main(String args[]){
Kitty c=new Kitty();
c.walk ();
c.sleep();
c.purr();
}}
Результат:
I will walk I will sleep I will purr
То есть, в конце мы обращаемся к методу walk() от Pet, потом к sleep() от Cat, а затем к purr () от Kitty.
Иерархическое наследование
Иерархическое наследование происходит, когда несколько подклассов получают разрешение от одного суперкласса:
class Pet{
public void walk(){
System.out.println ("I will walk");}
}
class Cat extends Pet{
public void sleep (){
System.out.println("I will sleep");}
}
class Kitty extends Pet{
public void purr(){
System.out.println("I will purr");}
}
class TestIn {
public static void main(String args[]){
Kitty c=new Kitty();
c.purr();
c.walk();
//c.sleep -Error
}}
Результат:
I will purr I will walk
Класс Kitty унаследовал от Pet walk(), а также у него есть свой purr (), соответственно метод sleep() от Cat ему не доступен.
Правила наследования
Написание кода подчиняется своим законам. В Java также есть определенные правила.
Обращение к методу родителя с помощью super
Чтобы обратиться к методу родителя, нужно использовать ключевое слово super.
Давайте используем один из предыдущих вариантов-примеров, добавив super в преобразованный Cow:
class Cow extends Pet{
// обращаемся к walk в Pet
super. walk ();
System.out.println("I will produce milk");}
public void moo (){
System.out.println ("I will moo");}
}
class TestIn{
public static void main (String args[]){
Cow small=new Cow();
small.walk ();
small. moo ();
}}
Результат:
I will walk I will produce milk I will moo
В главном Pet есть walk (), также и в расширенном Сow, но уже с приставкой super.walk (), мы обращаемся к walk () в суперкласс из подкласса.
Получение доступа к защищенным элементам и методам
Если protected (защищен) стоит перед элементами и методами — это указание на то, что к ним можно обратиться из производного класса:
class Pet {
protected String name;
protected void display ()
System.out.println (“I am a pretty pet”);
}
class Kitty extends Pet{
public void getInfo (){
System.out.println (" Call me .." + name);}
}
class TestIn{
public static void main (String args[]){
Kitty small=new Kitty();
// обращаемся к защищенному display
small.name = “Lilu”;
small.display ();
small.getInfo();
}}
Результат:
I am a pretty pet Call me Lilu
Как видно из примера, у нас есть основной класс — Pet — с защищенными name и display. Чтобы обойти эту защиту, мы создали новый объект small подкласса Kitty и получили необходимый доступ.
Наследовать можно всего один класс
Интересно, что в Java нет многократного наследования — оно возможно только от одного суперкласса.
ОШИБКА:
public class extends Pet, Сow, Cat {}
Важно! В Java класс не может унаследовать ничего сам от себя.
Наследуется все, кроме приватных переменных и методов
В Java модификатор private сообщает о том, что классы-наследники не получат от родителя элементы с таким обозначением. Если вы попробуете произвести extends, компилятор выдаст ошибку.
Как переделать метод класса-родителя
Override (переопределение) — мощный инструмент, который применяется, когда необходимо изменить или переопределить реализацию метода, полученного от суперкласса.
class Cow extends Pet{
@Override
public void walk (){
System.out.println ("I will run");}
Важные моменты при использовании Override:
- переопределить можно только унаследованные методы;
- название и параметры метода в родителе и наследнике — одинаковые;
- методы с обозначением private не переопределяются.
Как запретить наследование
Запретить создание подкласса можно просто применив final. Если класс отмечен как final, то ни один другой класс не может унаследовать от него элементы .
final class Pet {
}
class Kitty extends Pet {
}
В результате мы получим ошибку.
Pet обозначен как final, поэтому Kitty не может получить от него ни поля ни переменных .
Сообщить об опечатке
Текст, который будет отправлен нашим редакторам: