Wie implementiert man die erweiterte Methode anwenden? Java

Question

Meine Frage bezieht sich auf die Implementierung der FlatApply-Klasse, die ich zuvor in dieser Klasse namens FilteringFlatApplyFunction erstellt habe. Ich kann nicht scheinen, die zutreffende Anwendung richtig zu implementieren, weil die statische Klasse fortfährt, mir zu sagen, dass es abstrakt sein muss und das @Override nicht funktioniert, wie es soll. Das Endziel, nach dem ich suche, ist eine Möglichkeit, mithilfe von Vererbung den Großteil der Funktionalität aus der FlatApply-Klasse zu übernehmen und die Filterklasse zu implementieren. Ich habe viele verschiedene Dinge versucht, aber immer noch nicht, das Prädikat "pred" überprüft, ob das gegebene Prädikat wahr ist und wenn ja, gibt an, das Element zurückzugeben, ich dachte, dass FlatApply implementieren würde, habe ich diesen Fehler bekommen was scheint jetzt für immer. Dank

Fehler:

FilteringFlatApplyFunction nicht abstrakt ist und überschreibt nicht abstrakte Methode anwenden (T) in FlatApplyFunction wobei T ein Typ-Variable ist: T erweitert Objekt in der Klasse FilteringFlatApplyFunction erklärt

package iterators; 


import java.util.Iterator; 
import java.util.LinkedList; 
import java.util.List; 
import iterators.Apply; 

// Iterator that uses a Predicate to filter out elements from the input 
public class Filter<T> extends FlatApply<T,T> { 
     public Filter(Predicate<T> p, Iterator<T> input) {    
      super(new FilteringFlatApplyFunction<T>(p),input); 


} 

// uses a Predicate to decide whether the input element is output or not 

private static class FilteringFlatApplyFunction<T> implements FlatApplyFunction<T,T> {      
     private final Predicate pred;   

     public FilteringFlatApplyFunction(Predicate<T> p) {        
      this.pred = p; 

     }    
     @Override 
     public T apply(Iterator T) { 
      T result = null; 
      if((!T.hasNext())) throw new IllegalStateException(); 
       if (pred.check(T.next()) == true){ 
        result = (T) T.next(); 
        }     
       else{ 
        return (T) T; 
       } 

    } 

Hier

ist die FlatApply

package iterators; 


import java.util.Iterator; 
import java.util.LinkedList; 
import java.util.List; 
import java.util.Queue; 


public class FlatApply<InT,OutT> implements Iterator<OutT> { 

    private final Iterator<InT> input; 

    private final FlatApplyFunction<InT,OutT> f; 

    private final Queue<OutT> q; 



     public FlatApply(FlatApplyFunction<InT,OutT> f, Iterator<InT> input) {     
       this.input = input; 
       this.f = f; 
       this.q = new LinkedList<OutT>();   
    } 

    @Override 
    public boolean hasNext() { 
       if (!q.isEmpty()) { 
        return true; 
       } 
       else { 
        while(q.isEmpty() && input.hasNext()) { 
         List<OutT> result = f.apply(input.next()); 
         q.addAll(result); 
        } 
        if(q.isEmpty()) return false; 
        else return true; 
       } 
      } 
      @Override 
    public OutT next() { 

       if((!hasNext())) throw new IllegalStateException(); 
       return q.poll(); 
       } 


      } 

Hier ist der FlatApplyFuncti gelten auf

package iterators; 


import java.util.List; 


public interface FlatApplyFunction<InT, OutT> { 
     public List<OutT> apply(InT x); 
} 

die hier Klasse

package iterators; 


import java.util.Iterator; 

public class Apply<InT,OutT> implements Iterator<OutT> { 
    // The function that will be applied to each input element to make an  output element 
    private final ApplyFunction<InT,OutT> f; 

    // The Iterator that this Apply object will get its input from 
    private final Iterator<InT> input;  

    public Apply(ApplyFunction<InT, OutT> f, Iterator<InT> input) { 
       this.input = input; 
       this.f = f; 
    } 

    @Override 
    public boolean hasNext() { 
       return input.hasNext(); 
    } 

    @Override 
    public OutT next() { 
       if((!hasNext())) throw new IllegalStateException(); 
       OutT result = f.apply(input.next());     
       return result; 
    } 
} 

Answer 1

Die FlatApplyFunction Schnittstelle sagt dies:

public List<OutT> apply(InT x); 

Aber die FilteringFlatApplyFunction Implementierung dieser Schnittstelle sagt dieses:

public T apply(Iterator T) { 

Die Schnittstelle erfordert eine List zurückgegeben werden, indem Sie einfach T zurückgeben. Außerdem muss der Parameter ein T sein, aber Sie haben es als Iterator.

Machen Sie diese Übereinstimmungen, und dieser Compilerfehler sollte verschwinden.