Przyszło mi do głowy pytanie o utworzenie pojedynczego obiektu, w tym przykładzie a , gdzie za każdym razem, gdy uruchamiam metodę eat , wydrukuje ona jabłko, banan, w zamówienie, a następnie wróć do jabłka.

Jestem prawie pewien, że muszę utworzyć 3 klasy class apple class banana class peer, każda dziedzicząca class Order i każda ma metodę eat().

Jak mogę uczynić ten kod możliwym bez używania typów prymitywnych Java, pętli, instrukcji if i tylko przy użyciu funkcji obiektowych?

Order a = new Order();
//a will change state after each method is called.
a.eat(); // Prints "ate apple"
a.eat(); // Prints "ate banana"
a.eat(); // Prints "ate peer"
a.eat(); // Prints "ate apple"
a.eat(); // Prints "ate banana"
a.eat(); // Prints "ate peer"
0
Michael 18 grudzień 2019, 00:24
Jeśli tworzysz pojedynczy obiekt, którego zachowanie zmienia się za każdym razem, gdy wywołujesz metodę, nie ma to nic wspólnego z polimorfizmem, czyli tym, jak klasa dziedziczy zachowanie z innych typów.
 – 
azurefrog
18 grudzień 2019, 00:34
1
baeldung.com/java-state-design-pattern Stan wzorca projektowego, ale 3 dodatkowe zajęcia są nadal wymagane?
 – 
Evgeniy
18 grudzień 2019, 00:38
3 dodatkowe zajęcia nie są wymagane. Myślałem, że należy go użyć, ale może się mylić.
 – 
Michael
18 grudzień 2019, 00:53
Dlaczego to może być nie tak? Tworząc dodatkowy obiekt, użyjesz Polimorfizmu, który jest zorientowany na OOP. Jeśli chcesz poszerzyć go o dodatkowe owoce, możesz to łatwo zrobić. + Chcesz mieć całą logikę wewnątrz Zakonu NP używaj stanów do zmiany zachowania
 – 
Evgeniy
18 grudzień 2019, 01:12

2 odpowiedzi

Zanim zacznę, prawdopodobnie ma to lepsze rozwiązanie niż moje, ale szybkie, które właśnie wymyśliłem, to:

public class Order {

int iteration = 0;

public String eat() {

    if (iteration == 0) {
        iteration++;
        return "ate apple";
    } else if (iteration == 1) {
        iteration++;
        return "ate banana";
    } else if (iteration == 2) {
        iteration = 0;
        return "ate peer";
    } else {
        return null;
    }

}

}

Jak widać, ponieważ w dostarczonym kodzie tworzysz tylko jedną instancję Order, a następnie używam licznika int, aby śledzić, na której iteracji jesteśmy (tj. Jabłko, banan lub peer)

0
IdleApps Inc 18 grudzień 2019, 00:30

Ponieważ twój stan to czyste dane i nie ma z nim żadnego zachowania, myślę, że projekt pełnego stanu jest przesadą w przypadku tego problemu. Sugerowałbym, że najprostszym sposobem na zrobienie tego jest bardzo prosta, okrężna lista połączona z owocami w każdym węźle. Klasa Order może po prostu wydrukować dane z bieżącego węzła, a następnie przejść do następnego przy każdym wywołaniu eat().

Na przykład biorąc pod uwagę klasę Node i Order w ten sposób

class Node {
    Node next;
    String data;

    public Node(String data) {
        this.data = data;
    }
    public String getData() {
        return data;
    }
    public Node getNext() {
        return next;
    }
    public void setNext(Node next) {
        this.next = next;
    }
}
class Order {
    Node node;

    public Order() {
        Node apple = new Node("apple");
        Node banana = new Node("banana");
        Node pear = new Node("pear");

        apple.setNext(banana);
        banana.setNext(pear);
        pear.setNext(apple);

        this.node = apple;
    }

    public void eat() {
        System.out.println(node.getData());
        node = node.getNext();
    }
}

Uzyskasz pożądane zachowanie:

public static void main(String[] args) {
    Order a = new Order();
    a.eat(); // apple
    a.eat(); // banana
    a.eat(); // pear
    a.eat(); // apple
    a.eat(); // banana
    a.eat(); // pear
}
2
azurefrog 18 grudzień 2019, 00:52