16.8 RTTI действительно вредна?

//: DynaTrash.java
// Использование ассоциативного массива Vector и RTTI
// для автоматического сортирования мусора в
// векторах. Этот подход, несмотря на использование RTTI,
// является расширяемым.
package c16.dynatrash;
import c16.trash.*;
import java.util.*;

// Общий TypeMap работает в любой ситуации:
class TypeMap {
  private Hashtable t = new Hashtable();
  public void add(Object o) {
    Class type = o.getClass();
    if(t.containsKey(type))
      ((Vector)t.get(type)).addElement(o);
    else {
      Vector v = new Vector();
      v.addElement(o);
      t.put(type,v);
    }
  }
  public Vector get(Class type) {
    return (Vector)t.get(type);
  }
  public Enumeration keys() { return t.keys(); }
  // Возвращает обработчик адаптерного класса для возможности
  // обратного вызова из ParseTrash.fillBin():
  public Fillable filler() {
    // Анонимный внутренний класс:
    return new Fillable() {
      public void addTrash(Trash t) { add(t); }
    };
  }
}
```Пожалуйста, учтите, что использование `Hashtable`, `Vector` и `Enumeration` является устаревшим в современной Java. Рекомендую использовать более новые коллекции, такие как `HashMap`, `ArrayList` и `Iterator`. Хотя функционал очень мощный, но определение `TypeMap` довольно простое. Оно просто включает хэш-таблицу, а метод `add()` выполняет большую часть работы. При добавлении нового типа объект класса `Class` извлекается. Затем с помощью этого объекта проверяется, существует ли вектор (`Vector`), содержащий объекты данного типа, в хэш-таблице. Если такой вектор уже существует, он извлекается, и новый объект добавляется в него; если нет, то объект класса `Class` и новый пустой вектор добавляются как пара "ключ-значение".Метод `keys()` позволяет получить список всех объектов класса `Class`, а метод `get()` позволяет получить соответствующий вектор по объекту класса.

Метод `filler()` представляет интерес, так как он использует дизайн метода `ParseTrash.fillBin()`. Он может попытаться заполнить вектор, а также использовать метод `addTrash()` для заполнения любого объекта, который реализует интерфейс `Fillable`.

Для создания такого вызова метод `filter()` просто возвращает ссылку на объект, который реализует интерфейс `Fillable`, и передает эту ссылку в качестве параметра методу `fillBin()`, как показано ниже:

```java
ParseTrash.fillBin("Trash.dat", bin.filler());
```

Чтобы создать этот вызов, мы использовали "анонимный внутренний класс" (описанный в главе 7). Поскольку нам не требуется имя класса для реализации интерфейса `Fillable`, достаточно иметь ссылку на объект этого класса, использование анонимного внутреннего класса здесь вполне уместно.

Одной из особенностей этого дизайна является то, что хотя контроль над категориями не был предусмотрен, каждый раз при выполнении метода `fillBin()` объект класса `Trash` автоматически добавляется в контейнер `bin`.После просмотра предыдущих примеров большинство частей класса `DynaTrash` должны быть вам знакомыми. На этот раз вместо помещения новых объектов класса `Trash` в векторы типа `bin`, мы используем механизм внутренней классификации `TypeMap`. Процесс прохождения через `TypeMap` и операция со всеми отдельными векторами оказывается довольно простым делом.

Перебор ключей происходит следующим образом:```java
Перечисление ключей = бин.ключи();
пока(ключи.естьЕщеЭлементы()) {
  Trash.суммаЗначения(бин.получить((Класс)ключи.следующийЭлемент()));
}
```

Как видно, добавление новых типов в систему никак не влияет на эти коды, а также не затрагивает код `TypeMap`. Это явно является наиболее полным решением проблемы. Хотя этот подход действительно сильно зависит от RTTI, стоит отметить, что каждый ключ-значение в хэш-таблице проверяет только один тип. Кроме того, при добавлении нового типа мы не оказываемся в ситуации "забывчивости" относительно добавления правильного кода в систему, так как вообще ничего добавлять не требуется.
```