Recuperatorio 2023 1C - Ejercicio 2

Hola! Quería consultar si en este ejercicio esta bien hacer que las clases hijas le pasen el Comparator por parámetro al constructor de la clase padre, en lugar de que la clase padre sea abstracta y tenga un método abstracto que las clases hijas tengan que sobreescribir para determinar el Comparator. El código me quedó así:

public class WordCountCatalog implements Iterable<WordCount>{
    private WordCount[] catalog;
    private final Comparator<WordCount> cmp;
    private static final int INITIAL_DIM = 5;
    private int dim;

    public WordCountCatalog(Comparator<WordCount> cmp){
        catalog = new WordCount[INITIAL_DIM];
        this.cmp = cmp;
    }
    public WordCountCatalog add(WordCount wc){
        if(dim == catalog.length){
            resize();
        }
        catalog[dim++] = wc;
        return this;
    }

    private void resize(){
        catalog = Arrays.copyOf(catalog, dim + INITIAL_DIM);
    }

    public WordCount getByIndex(int index){
        if(index < 0 || index >= dim){
            throw new IllegalArgumentException();
        }
        return catalog[index];
    }

    @Override
    public Iterator<WordCount> iterator(){
        WordCount[] copy = Arrays.copyOf(catalog, dim);
        Arrays.sort(copy, cmp);
        return new Iterator<>(){
            private int current = 0;

            @Override
            public boolean hasNext(){
                return current < copy.length;
            }

            @Override
            public WordCount next(){
                if(!hasNext()){
                    throw new NoSuchElementException();
                }
                return copy[current++];
            }
        };
    }
}

public class AlphabeticalWordCatalog extends WordCountCatalog{
    public AlphabeticalWordCatalog(){
        super(new Comparator<>(){
            @Override
            public int compare(WordCount wc1, WordCount wc2){
                int toReturn = wc1.getWord().compareTo(wc2.getWord());
                if(toReturn == 0){
                    toReturn = Integer.compare(wc1.getCount(), wc2.getCount());
                }
                return toReturn;
            }
        });
    }
}

public class DescendingCountCatalog extends WordCountCatalog{
    public DescendingCountCatalog(){
        super(new Comparator<>(){
            @Override
            public int compare(WordCount wc1, WordCount wc2){
                int toReturn = Integer.compare(wc2.getCount(), wc1.getCount());
                if(toReturn == 0){
                    toReturn = wc2.getWord().compareTo(wc1.getWord());
                }
                return toReturn;
            }
        });
    }
}

POO-ITBA / 2024_01

Recuperatorio 2023 1C - Ejercicio 2 #10