public boolean put(@ParametricNullness K key, @ParametricNullness V value) {
    return super.put(key, value);
  }

  /**
   * {@inheritDoc}
   *
   * <p>Though the method signature doesn't say so explicitly, the returned map has {@link List}
   * values.
   */
  @Override
  public Map<K, Collection<V>> asMap() {
    return super.asMap();
  }

  /**

  public TestWriter(TestOutputStream out) {
    super(new OutputStreamWriter(checkNotNull(out), UTF_8));
    this.out = out;
  }

  @Override
  public void write(int c) throws IOException {
    super.write(c);
    flush(); // flush write to TestOutputStream to get its behavior
  }

  @Override
  public void write(char[] cbuf, int off, int len) throws IOException {
    super.write(cbuf, off, len);
    flush();
  }

    }
    super.moveLastEntry(dstIndex);
  }

  @Override
  void resizeEntries(int newCapacity) {
    super.resizeEntries(newCapacity);
    int oldCapacity = links.length;
    links = Arrays.copyOf(links, newCapacity);
    Arrays.fill(links, oldCapacity, newCapacity, UNSET);
  }

  @Override
  public void clear() {
    super.clear();
    this.firstEntry = ENDPOINT;

    public MavenExecutionRequestPopulationException(String message) {
        super(message);
    }

    public MavenExecutionRequestPopulationException(Throwable cause) {
        super(cause);
    }

    public MavenExecutionRequestPopulationException(String message, Throwable cause) {
        super(message, cause);
    }

    super(channel);
    this.path = path;
  }

  TunnelingUnixSocket(File path, UnixSocketChannel channel, InetSocketAddress address) {
    this(path, channel);
    this.inetSocketAddress = address;
  }

  @Override public void connect(SocketAddress endpoint) throws IOException {
    this.inetSocketAddress = (InetSocketAddress) endpoint;
    super.connect(new UnixSocketAddress(path), 0);
  }

    implements SortedMultiset<E> {
  UnmodifiableSortedMultiset(SortedMultiset<E> delegate) {
    super(delegate);
  }

  @Override
  protected SortedMultiset<E> delegate() {
    return (SortedMultiset<E>) super.delegate();
  }

  @Override
  public Comparator<? super E> comparator() {
    return delegate().comparator();
  }

  @Override
  NavigableSet<E> createElementSet() {

      extends AbstractCatchingFuture<V, X, Function<? super X, ? extends V>, V> {
    CatchingFuture(
        ListenableFuture<? extends V> input,
        Class<X> exceptionType,
        Function<? super X, ? extends V> fallback) {
      super(input, exceptionType, fallback);
    }

    @Override
    @ParametricNullness
    V doFallback(Function<? super X, ? extends V> fallback, X cause) throws Exception {

        super(createMessage(message, projectId, null), cause);
        this.projectId = projectId;
    }

    /**
     * @param projectId
     * @param message
     * @param pomFile   pom file location
     */
    public ProjectBuildingException(String projectId, String message, File pomFile) {
        super(createMessage(message, projectId, pomFile));

 * The maven super model

 * how parent poms are processed

 * the order in which elements in the POM are overridden

 * minimum element-set for a valid project pom


Maven super model

 Inheritance is recursive in Maven but there is a special model which is the implicit super parent in the lineage
 of models you may specify:

      public void write(int c) throws IOException {
        super.write(c);
        flush();
      }

      @Override
      public void write(char[] cbuf, int off, int len) throws IOException {
        super.write(cbuf, off, len);
        flush();
      }

      @Override
      public void write(String str, int off, int len) throws IOException {
        super.write(str, off, len);
        flush();
      }
    };
  }