Variare l'ordine del metodo di chiamata per diverse istanze di una classe

Question

Qual è il modo migliore di manipolare l'ordine mentre le cose vengono eseguite in base ad alcune condizioni (oltre a scriverle di nuovo con il diverso ordine)?

Diciamo che c'è una classe Persona e ogni oggetto di Persona rappresenta un diverso umano.

class Person{ 
    int eatingPriority = 3; 
    int sleepingPriority = 2; 
    int recreationPriority = 1; 

    void eat() {/*eats*/} 
    void sleep() {/*sleeps*/} 
    void watchTv() {/*watches tv*/} 

    void satisfyNeeds() { 
     //HOW TO DO THIS 
    } 
} 

Come posso fare i metodi satisfyNeeds() chiamano gli altri tre metodi in base alla loro priorità?

Nota: desidero chiarire che le priorità possono cambiare da Persona a Persona.

Answer 1

È possibile utilizzare questo codice

import java.util.Arrays; // must be imported 
int[] priorities = {sleepPriority, eatPriority, recreationPriority}; 
Arrays.sort(priorities); 
for (int i=priorities.length-1; 0<=i; i--) { 
    int priority = priorities[i]; 
    if (priority == sleepingPriority) { sleep(); } 
    if (priority == eatingPriority) { eat(); } 
    if (priority == recreationPriority) { watchTv(); } 
} 

Fondamentalmente, si mette le priorità in un array, ordina l'array e gestisce un ciclo for su di esso per eseguire le funzioni.

Answer 2

Si dovrebbe introdurre una Carta in Person di classe, in cui la priorità i metodi, per esempio:

class Person { 

... 
private Map<Integer, Method> methodsPriority = new HashMap<>(); 
... 
public Person setEatingPriority(int priority) { 

    methodsPriority.put(priority, /* put 'eat' method reference here*/); 
    return this; 
} 

public Person setSleepingPriority(int priority) { 

    methodsPriority.put(priority, /* put 'sleep' method reference here*/); 
    return this; 
} 

public Person setWatchingTVPriority(int priority) { 

    methodsPriority.put(priority, /* put 'watch TV' method reference here*/); 
    return this; 
} 

public void satisfyNeeds() { 

    Collection<Integer> keys = methodsPriority.keySet(); 
    Collections.sort(keys); 
    for(Integer key: keys) 
    methodsPriority.get(key).invoke(this); 
} 



... 
} 

e può essere utilizzato in prossimo maniera:

Person Anna = new Person() 
.setEatingPriority(1) 
.setSleepingPriority(2) 
.setWatchingTVPriority(3); 

Person Bob = new Person() 
.setEatingPriority(3) 
.setSleepingPriority(2) 
.setWatchingTVPriority(1); 

Anna.satisfyNeeds(); 
Bob.satisfyNeeds(); 

Answer 3

Si può fare questo con 1 classe e 1 interfaccia.

public class Person { 
    int eatingPriority = 3; 
    int sleepingPriority = 2; 
    int recreationPriority = 1; 

    PriorityQueue<Action> actions; 

    void eat() { } 

    void sleep() { } 

    void watchTv() { } 

    public Person() { 
     actions = new PriorityQueue<Action>(new Comparator<Action>() { 
      @Override 
      public int compare(Action o1, Action o2) { 
       return o2.getPriority() - o1.getPriority(); 
      } 
     }); 

     actions.add(new Action() { 
      @Override 
      public int getPriority() { 
       return eatingPriority; 
      } 
      @Override 
      public void execute() { 
       eat(); 
      } 
     }); 

     actions.add(new Action() { 
      @Override 
      public int getPriority() { 
       return sleepingPriority; 
      } 
      @Override 
      public void execute() { 
       sleep(); 
      } 
     }); 

     actions.add(new Action() { 
      @Override 
      public int getPriority() { 
       return recreationPriority; 
      } 
      @Override 
      public void execute() { 
       watchTv(); 
      } 
     }); 
    } 

    public void satisfyNeeds() { 
     for (Action action : actions) { 
      action.execute(); 
     } 
    } 

    interface Action { 
     public int getPriority(); 
     public void execute(); 
    } 
} 

Answer 4

Ecco un altro possibile implementazione:

abstract class Need { 
    abstract void satisfy(); 
} 

class Eat extends Need { 
    @Override 
    public void satisfy() { /* eat ...*/} 
} 

class Sleep extends Need { 
    @Override 
    public void satisfy() { /* sleep ...*/} 
} 

class DrinkBeer extends Need { 
    @Override 
    public void satisfy() { /* drink beer ...*/} 
} 

class Person{ 
    // TreeMap will sort the map in the key's natural order (a int here) 
    private Map<Integer, Need> needs = new TreeMap<>();  

Person() { 
    add(new Eat(), 3); 
    add(new Sleep(), 2); 
    add(new DrinkBeer(), 1); 
} 

void add(Need need, int priority) { 
    needs.put(Integer.valueOf(priority), need); 
} 

void satisfyNeeds() { 
    for(Need need : needs.values()) 
     need.satisfy(); 
    } 
} 

Answer 5

Trovare il giusto ordine dei tre elementi può essere fatto semplicemente in questo modo:

void satisfyNeeds() { 
    boolean eatFirst = eatingPriority>Math.max(sleepingPriority,recreationPriority); 
    if(eatFirst) eat(); 
    if(sleepingPriority>recreationPriority) { 
     sleep(); 
     watchTv(); 
    } 
    else { 
     watchTv(); 
     sleep(); 
    } 
    if(!eatFirst) eat(); 
    } 

Naturalmente, non scala se aumenti il ​​numero di azioni. Per un numero più alto potresti guardare una delle altre risposte.

Answer 6

Questa soluzione richiede Java 8:

class Person { 

    void eat() {}; 
    void sleep() {}; 
    void watchTv() {}; 

    // Being in a List you can easily reorder the needs when you want to 
    List<Runnable> needs = Arrays.asList(this::eat, this::sleep); 

    // Alternatively, you can use a Map<Runnable, Integer> where the value is your 
    // priority and sort it (see http://stackoverflow.com/q/109383/1296402) 

    void satisfyNeeds() { 
     needs.forEach(r -> r.run()); 
    } 
}