O co chodzi w tym fragmencie kodu?

addParagraph(
                        new ParagraphWithList().setContent("Umiejętności")
                                .addListItem("C")
                                .addListItem("C++")
                                .addListItem("Java")
                 );

Nie ogarniam jakie mechanizmy tutaj działają, ale bodajże trzeba ogarnąć dobrze co która funkcja ma zwrócić, żeby to podziałało. No więc jak to zrobić?
Szczególnie nie ogarniam jak ma się zachować ta funkcja addListItem i co ma zwrócić setContent.

Wygląda na fluent builder

Edit: Chyba ładniej to jednak zrobić za pomocą klasy immutable + chain methods:

class ParagraphWithList {

    private final String content;
    private final List<String> items;

    ParagraphWithList() {
        this("", Collections.emptyList());
    }

    private ParagraphWithList(String content, List<String> items) {
        this.content = content;
        this.items = Collections.unmodifiableList(items);
    }

    ParagraphWithList setContent(String newContent) {
        return new ParagraphWithList(newContent, items);
    }

    ParagraphWithList addListItem(String newItem) {
        var newItems = new ArrayList<>(items);
        newItems.add(newItem);
        return new ParagraphWithList(content, newItems);
    }
}

Wciąż to średnio ogarniam.
Przerobiłem twój kod na taki, który jest zgodny z warunkami mojego zadania i "Exception in thread "main" java.lang.NullPointerException
at UnorderedList.add(UnorderedList.java:9)".

public class ParagraphWithList extends Paragraph{

    UnorderedList unorderedList;

    ParagraphWithList() {

    }

    public ParagraphWithList(String text, UnorderedList list) {
        this.text = text;
        this.unorderedList = list;
    }

    ParagraphWithList setContent(String text)
    {
        return new ParagraphWithList(text, unorderedList);
    }

    ParagraphWithList addListItem(String newItem) {
        var newItems = new UnorderedList();
        newItems.add(newItem);
        return new ParagraphWithList(text, newItems);
    }

}

public class UnorderedList extends  ParagraphWithList{

    List<ListItem> list;

    public void add(String item)
    {
        list.add(new ListItem((item)));
    }

}

public class ListItem {
    String text;

    public ListItem(String s) {
        this.text = s;
    }
}

Zmienna List<ListItem> list; w klasie UnorderedList jest niezainicjalizowana. Powinno być:

List<ListItem> list = new LinkedList<>();

a najlepiej:

private final List<ListItem> list = new LinkedList<>();

Kamil Żabiński napisał(a):

Zmienna List<ListItem> list; w klasie UnorderedList jest niezainicjalizowana. Powinno być:

List<ListItem> list = new List<>();

a najlepiej:

private final List<ListItem> list = new List<>();

To działa pod warunkiem, że dodam bardzo dużo nowych linii kodu, które zaproponowało mi IDE, do klasy UnorderedList. W sensie aż tyle:

@Override
        public int size() {
            return 0;
        }

        @Override
        public boolean isEmpty() {
            return false;
        }

        @Override
        public boolean contains(Object o) {
            return false;
        }

        @Override
        public Iterator<ListItem> iterator() {
            return null;
        }

        @Override
        public Object[] toArray() {
            return new Object[0];
        }

        @Override
        public <T> T[] toArray(T[] ts) {
            return null;
        }

        @Override
        public boolean add(ListItem listItem) {
            return false;
        }

        @Override
        public boolean remove(Object o) {
            return false;
        }

        @Override
        public boolean containsAll(Collection<?> collection) {
            return false;
        }

        @Override
        public boolean addAll(Collection<? extends ListItem> collection) {
            return false;
        }

        @Override
        public boolean addAll(int i, Collection<? extends ListItem> collection) {
            return false;
        }

        @Override
        public boolean removeAll(Collection<?> collection) {
            return false;
        }

        @Override
        public boolean retainAll(Collection<?> collection) {
            return false;
        }

        @Override
        public void clear() {

        }

        @Override
        public boolean equals(Object o) {
            return false;
        }

        @Override
        public int hashCode() {
            return 0;
        }

        @Override
        public ListItem get(int i) {
            return null;
        }

        @Override
        public ListItem set(int i, ListItem listItem) {
            return null;
        }

        @Override
        public void add(int i, ListItem listItem) {

        }

        @Override
        public ListItem remove(int i) {
            return null;
        }

        @Override
        public int indexOf(Object o) {
            return 0;
        }

        @Override
        public int lastIndexOf(Object o) {
            return 0;
        }

        @Override
        public ListIterator<ListItem> listIterator() {
            return null;
        }

        @Override
        public ListIterator<ListItem> listIterator(int i) {
            return null;
        }

        @Override
        public List<ListItem> subList(int i, int i1) {
            return null;
        }
    };

A jak nie dodasz tego kodu co ppodpowiada Ci IDE to co się dzieje? Na moje oko ten "dziwny kod" podpowiadany przez IDE jest bo gdzieś dodałeś dziedziczenie po interfejsie `List` Miało być `new LinkedList()` zamiast `new List()`. `List` w Javie to tylko interfejs, a musisz użyć konkretnej klasy. Do wyboru jest `LinkedList` i `ArrayList` z klas najprostrzych.