Опубликован: 11.12.2003 | Уровень: специалист | Доступ: платный
Лекция 8:

Объектная модель в Java

< Лекция 7 || Лекция 8: 12345 || Лекция 9 >

Ключевые слова this и super

Эти ключевые слова уже упоминались, рассматривались и некоторые случаи их применения. Здесь они будут описаны более подробно.

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

class Test {
   public Object getThis() {
      return this;   
      // Проверим, куда указывает эта ссылка
   }
   public static void main(String s[]) {
      Test t = new Test();
      System.out.println(t.getThis()==t);   
	  // Сравнение
   }
}

Результатом работы программы будет:

true

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

class Human {
   public static void register(Human h) {
      System.out.println(h.name+
        " is registered.");
   }

   private String name;
   public Human (String s) {
      name = s;
      register(this); // саморегистрация
   }

   public static void main(String s[]) {
      new Human("John");
   }
}

Результатом будет:

John is registered.

Другое применение this рассматривалось в случае "затеняющих" объявлений:

class Human {
   private String name;

   public void setName(String name) {
      this.name=name;
   }
}

Слово this можно использовать для обращения к полям, которые объявляются ниже:

class Test {
   // int b=a; нельзя обращаться к 
   // необъявленному полю!
   int b=this.a;
   int a=5;
   {
      System.out.println("a="+a+", b="+b);
   }
   public static void main(String s[]) {
      new Test();
   }
}

Результатом работы программы будет:

a=5, b=0

Все происходит так же, как и для статических полей – b получает значение по умолчанию для a, т.е. ноль, а затем a инициализируется значением 5.

Наконец, слово this применяется в конструкторах для явного вызова в первой строке другого конструктора этого же класса. Там же может применяться и слово super, только уже для обращения к конструктору родительского класса.

Другие применения слова super также связаны с обращением к родительскому классу объекта. Например, оно может потребоваться в случае переопределения (overriding) родительского метода.

Переопределением называют объявление метода, сигнатура которого совпадает с одним из методов родительского класса.

class Parent {
   public int getValue() {
      return 5;
   }
}

class Child extends Parent {
   // Переопределение метода
   public int getValue() {
     return 3;
   }


   public static void main(String s[]) {
     Child c = new Child();

     // пример вызова переопределенного метода
     System.out.println(c.getValue());
   }
}

Вызов переопределенного метода использует механизм полиморфизма, который подробно рассматривается в конце этой лекции. Однако ясно, что результатом выполнения примера будет значение 3. Невозможно, используя ссылку типа Child, получить из метода getValue() значение 5, родительский метод перекрыт и уже недоступен.

Иногда при переопределении бывает полезно воспользоваться результатом работы родительского метода. Предположим, он делал сложные вычисления, а переопределенный метод должен вернуть округленный результат этих вычислений. Понятно, что гораздо удобнее обратиться к родительскому методу, чем заново описывать весь алгоритм. Здесь применяется слово super. Из класса наследника с его помощью можно обращаться к переопределенным методам родителя:

class Parent {
   public int getValue() {
      return 5;
   }
}

class Child extends Parent {

   // переопределение метода
   public int getValue() {
      // обращение к методу родителя
      return super.getValue()+1;
   }

   public static void main(String s[]) {
      Child c = new Child();
      System.out.println(c.getValue());
   }
}

Результатом работы программы будет значение 6.

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

Поскольку ключевые слова this и super требуют наличия ассоциированного объекта, т.е. динамического контекста, использование их в статическом контексте запрещено.

Ключевое слово abstract

Следующее важное понятие, которое необходимо рассмотреть,– ключевое слово abstract.

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

Рассмотрим пример. Предположим, необходимо создать набор графических элементов, неважно, каких именно. Например, они могут представлять собой геометрические фигуры – круг, квадрат, звезда и т.д.; или элементы пользовательского интерфейса – кнопки, поля ввода и т.д. Сейчас это не имеет решающего значения. Кроме того, существует специальный контейнер, который занимается их отрисовкой. Понятно, что внешний вид каждой компоненты уникален, а значит, соответствующий метод (назовем его paint() ) будет реализован в разных элементах по-разному.

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

Но как поступить с методом отрисовки? Ведь родительский класс не представляет собой какую-либо фигуру, у него нет визуального представления. Можно объявить метод paint() в каждой компоненте независимо. Но тогда контейнер должен будет обладать сложной функциональностью, чтобы анализировать, какая именно компонента сейчас обрабатывается, выполнять приведение типа и только после этого вызывать нужный метод.

Именно здесь удобно объявить абстрактный метод в родительском классе. У него нет внешнего вида, но известно, что он есть у каждого наследника. Поэтому заголовок метода описывается в родительском классе, тело метода у каждого наследника свое, а контейнер может спокойно пользоваться только базовым типом, не делая никаких приведений.

Приведем упрощенный пример:

// Базовая арифметическая операция
abstract class Operation {
  public abstract int calculate(int a, int b);
}
// Сложение
class Addition extends Operation {
  public int calculate(int a, int b) {
    return a+b;
   }
}

// Вычитание
class Subtraction extends Operation {
   public int calculate(int a, int b) {
      return a-b;
   }
}

class Test {
   public static void main(String s[]) {
      Operation o1 = new Addition();
      Operation o2 = new Subtraction();

      o1.calculate(2, 3);
      o2.calculate(3, 5);
   }
}

Видно, что выполнения операций сложения и вычитания в методе main() записываются одинаково.

Обратите внимание – поскольку абстрактный метод не имеет тела, после описания его заголовка ставится точка с запятой. А раз у него нет тела, то к нему нельзя обращаться, пока его наследники не опишут реализацию. Это означает, что нельзя создавать экземпляры класса, у которого есть абстрактные методы. Такой класс сам объявляется абстрактным.

Класс может быть абстрактным и в том случае, если у него нет абстрактных методов, но должен быть абстрактным, если такие методы есть. Разработчик может указать ключевое слово abstract в списке модификаторов класса, если хочет запретить создание экземпляров этого класса. Классы-наследники должны реализовать (implements) все абстрактные методы (если они есть) своего абстрактного родителя, чтобы их можно было объявлять неабстрактными и порождать от них экземпляры.

Конечно, класс не может быть одновременно abstract и final. Это же верно и для методов. Кроме того, абстрактный метод не может быть private, native, static.

Сам класс может без ограничений пользоваться своими абстрактными методами.

abstract class Test {
   public abstract int getX();
   public abstract int getY();
   public double getLength() {
      return Math.sqrt(getX()*getX()+
                       getY()*getY());
   }
}

Это корректно, поскольку метод getLength() может быть вызван только у объекта. Объект может быть порожден только от не абстрактного класса, который является наследником от Test, и должен был реализовать все абстрактные методы.

По этой же причине можно объявлять переменные типа абстрактный класс. Они могут иметь значение null или ссылаться на объект, порожденный от неабстрактного наследника этого класса.

< Лекция 7 || Лекция 8: 12345 || Лекция 9 >
Илья Ардов
Илья Ардов

Добрый день!

Я записан на программу. Куда высылать договор и диплом?

Георгий Кузнецов
Георгий Кузнецов

1. По истечению срока курса, будет ли доступ к курсу закрыт? (в данном случае написано 29 января)

2. Так и не понял: что такое конструктор?

Анна Митина
Анна Митина
Россия, Москва, City Business School
Голубчик Никита
Голубчик Никита