Ключевое слово super используется при наследовании классов Java. В Java суперкласс является родительским классом текущего класса. Текущий класс является дочерним классом (подклассом) суперкласса. Существует вероятность того, что классы внуков и правнуков пойдут вниз. Родительский класс является прямым суперклассом текущего класса. Прародительский класс не является прямым суперклассом текущего класса. В этой статье объясняется использование ключевого слова super в Java. Он начинается с представления родительского класса, потомка родительского класса и внука родительского класса. Затем он показывает, как слово «супер» вписывается в иерархию. Иерархия ниже формирует форму Калькулятора.
Recall of Java Inheritance
Рассмотрим следующий класс:
class Cparent {
int a;
int b;
int add() {
return a + b;
}
}
Этот класс имеет два свойства: a и b. В Java свойства называются полями. Этот класс имеет один метод, который добавляет два числа, которые являются значениями поля. Имя класса — Cparent с предшествующей буквой C для калькулятора. Следующий сегмент кода в методе main() выводит 5:
Cparent parent = new Cparent();
parent.a = 2;
parent.b = 3;
int rAdd = parent.add();
System.out.println(rAdd);
Рассмотрим следующий класс, который является подклассом вышеуказанного класса (Cparent):
class Cchild extends Cparent {
int c;
int multiply() {
return a * c;
}
}
Обратите внимание на использование ключевого слова extends. Этот класс имеет поле с и метод умножить(). Класс наследует поля ’a’ и b и метод add(). Однако, если значение поля для ’a’ или b должно использоваться для этого текущего созданного объекта (дочернего объекта), ему все равно необходимо переназначить значение. Для этого класса унаследованное значение ’a’ умножается на значение поля класса c. Имя этого класса Cchild с предшествующей буквой C для калькулятора. Для этого класса подходит следующий фрагмент кода в методе main():
Cchild child = new Cchild();
child.a = 2;
child.c = 4;
int rMult = child.multiply();
System.out.println(rMult);
Результат равен 8. Обратите внимание, что, хотя поле ’a’ было унаследовано, ему все равно нужно было переназначить значение; в данном случае одно и то же значение.
Рассмотрим следующий класс, который является подклассом вышеприведенного класса Cchild:
class CgrandChild extends Cchild {
int d;
int divide() {
return a / d;
}
}
Обратите внимание на использование ключевого слова extends. Этот класс имеет поле d и метод Division(). Класс наследует члены ’a’, b и add() от класса Cchild, который унаследовал их от класса Cparent. Он также наследует члены, c, иmultiple() от класса Cchild. Однако, если значение поля для ’a’ или b или c из родительского или прародительского классов должно использоваться для этого текущего созданного объекта (внучатого объекта), ему все равно необходимо переназначить значение. Для этого класса унаследованное значение ’a’ делится на значение поля класса d. Имя этого класса — CgrandChild с предшествующей буквой C для калькулятора. Для этого класса подходит следующий фрагмент кода в методе main():
CgrandChild gChild = new CgrandChild();
gChild.a = 2;
gChild.d = 2;
int rDiv = gChild.divide();
System.out.println(rDiv);
Результатом является 1. Обратите внимание, что, хотя поле ’a’ было унаследовано, ему все же нужно было переназначить значение; в данном случае то же значение, 2.
Использование super Keyword
Field и super
В приведенной выше программе значение поля «a» было установлено три раза: один раз для родительского объекта, один раз для дочернего объекта и один раз для дочернего объекта. Чтобы избежать этого сброса каждый раз, значение 2 можно присвоить один раз в реализации (определении) родительского класса следующим образом:
class Cparent {
int a = 2;
int b;int add() {
return a + b;
}
}
Это решает проблему сброса для каждого объекта-потомка. В классах-потомках поле ’a’ просто упоминается (обычно).
Чтобы получить доступ к значению унаследованного поля, необходимо использовать ключевое слово super в интересующей реализации класса-потомка, как показано ниже:
super.fieldName
Следующий сегмент кода показывает, как был получен доступ к имени ’a’ в новой реализации Cchild:
class Cchild extends Cparent {
int p = super.a;
int c;
int multiply() {
return p * c;
}
}
Класс Cchild теперь имеет собственное имя, p вместо ’a’. Итак, оператор в методе add(),
return a * c;
сейчас,
return p * c;
Аналогичным образом, реализация класса CgrandChild может заменить «a» на q следующим образом:
class CgrandChild extends Cchild {
int q = super.a;
int d;
int divide() {
return q / d;
}
}
Примечание. Наследование происходит во всех классах-потомках. Поле ’a’ и метод add() наследуются в классе Cchild и в классе CgrandChild.
Method и super
Аналогично, доступ к унаследованному полю можно получить в реализации класса-потомка; к унаследованному методу также можно получить доступ в классе-потомке, используя ключевое слово super. Синтаксис:
super.methodName()
Реализация исходного класса Cchild может быть изменена следующим образом:
class Cchild extends Cparent {
int c;
int sum = super.add();
int multiply() {
return a * c;
}
}
Обратите внимание, что использование super. Унаследованный метод add() теперь рассматривается как «сумма» в реализации Cchild. Поле с и метод умножить() все еще там. Сегмент кода для добавления в метод main(), который подходит этому модифицированному классу Cchild:
Cchild child = new Cchild();
int rSum = child.sum;
System.out.println(rSum);
Выход равен 5, при условии, что родительский класс был изменен с помощью:
int a = 2;
int b = 3;
Constructor и super
Конструктор по умолчанию, который не реализован, наследуется в каждом классе-потомке и не должен учитываться при реализации потомков и в методе main(). Однако, как только родительский класс имеет собственный конструктор, остальные его потомки должны иметь аналогичный конструктор. Рассмотрим родительский класс с пользовательским конструктором следующим образом:
class Cparent {
int a, b;
public Cparent(int x, int y) {
a = x; b = y;
}
int add() {
return a + b;
}
}
Поля ’a’ и b объявляются без присваивания. Конструктор выполняет задание. Дочерний класс должен иметь такой же или подобный конструктор. Соответствующий дочерний класс для исходной иерархии калькулятора может быть:
class Cchild extends Cparent {
Cchild(int x, int y) {
super(x, y);
}
int c;
int multiply() {
return a * c;
}
}
Конструктор здесь такой же, как и у родителя. Тело конструктора здесь просто имеет:
super(x, y);
который просто вызывает конструктор родителя с полученными аргументами. «super» здесь представляет конструктор родительского класса. Это еще одно использование super. В этом дочернем конструкторе нет изменений. Соответствующий дочерний класс для исходной иерархии калькулятора может быть:
class CgrandChild extends Cchild {
int d;
CgrandChild(int x, int y, int z) {
super(x, y);
d = z;
}
int divide() {
return a / d;
}
}
Конструктор здесь изменен. Он имеет те же параметры x и y и дополнительный параметр z. z — это присвоение значения делителю d. Тело конструктора начинается с вызова конструктора родительского класса. Затем назначается поле для делителя. Для этого класса подходит следующий фрагмент кода в методе main():
CgrandChild gChild = new CgrandChild(2, 3, 2);
int rDiv = gChild.divide();
System.out.println(rDiv);
Выход для этого равен 1.
Заключение
Super будет искать что-то в непосредственном родительском классе. Если он не увидит его там, он будет искать его в прародительском классе. Если он не увидит его там, он будет искать его в классе прародителей; и так далее, пока либо не увидит, либо не увидит. «супер» обычно используется в реализации подкласса. Он используется для поля, метода и конструктора. Прямой суперкласс является родительским классом. Прародительский класс является надклассом, но не прямым надклассом.
