Как отслеживать значение переменной из другого класса

Question

Я создаю класс Player для своей игры, и мне нужен способ отслеживания элементов управления, но я хочу отследить клавиатуру отдельно от класса hitbox/rendering. Я код настройки для сохранения значения определенных ключей (W, A, S, D и ▲, ◄, ▼, ►) в переменных, в моем основной класс. Я хочу как-то указать на переменные в конструкторе и как-то их отследить.

Один из способов решения проблемы - заменить переменную w на player2.up и т. Д., Поэтому мои методы отслеживания клавиатуры непосредственно редактируют объекты Player, но это не так гибко. Я мог бы также передать вызывающий объект конструктору, но это еще менее гибко. На данный момент мне придется отследить клавиатуру из класса проигрывателя, но было бы здорово как-то ссылаться на переменные.

Я должен был пройти константы, поставляемые с интерфейсом KeyListener в то же время, но вот код:

package learn_game_programming; 

import java.awt.Component; 
import java.awt.Dimension; 
import java.awt.Graphics; 
import java.awt.Point; 
import java.awt.Rectangle; 
import java.awt.event.ActionEvent; 
import java.awt.event.KeyEvent; 
import java.awt.event.KeyListener; 

public class Player extends Rectangle { 

    private static final long serialVersionUID = 6027220656827265195L; 

    int upKey; 
    int downKey; 
    int leftKey; 
    int rightKey; 
    boolean up; 
    boolean down; 
    boolean left; 
    boolean right; 
    int ym; 
    int xm; 
    KeyboardTracker keyListener; 
    Component caller; 
    String name; 

    public Player() { 
     // TODO Auto-generated constructor stub 
    } 

    public Player(Rectangle r) { 
     super(r); 
     // TODO Auto-generated constructor stub 
    } 

    public Player(Point p) { 
     super(p); 
     // TODO Auto-generated constructor stub 
    } 

    public Player(Dimension d) { 
     super(d); 
     // TODO Auto-generated constructor stub 
    } 

    public Player(int width, int height) { 
     super(width, height); 
     // TODO Auto-generated constructor stub 
    } 

    public Player(Point p, Dimension d) { 
     super(p, d); 
     // TODO Auto-generated constructor stub 
    } 

    public Player(String name, int x, int y, int width, int height, int upKey, int downKey, int leftKey, int rightKey, Component caller) { 
     super(x, y, width, height); 
     this.upKey = upKey; 
     this.downKey = downKey; 
     this.leftKey = leftKey; 
     this.rightKey = rightKey; 
     this.keyListener = new KeyboardTracker(); 
     this.caller = caller; 
     caller.addKeyListener(this.keyListener); 
     this.name = name; 
    } 

    private class KeyboardTracker implements KeyListener{ 
     public void keyPressed(KeyEvent ke){ 
      int key = ke.getKeyCode(); 
      if(key == upKey){ 
       up = true; 
      } 
      if(key == downKey){ 
       down = true; 
      } 
      if(key == leftKey){ 
       left = true; 
      } 
      if(key == rightKey){ 
       right = true; 
      } 
     } 

     public void keyReleased(KeyEvent ke){ 
      int key = ke.getKeyCode(); 
      if(key == upKey){ 
       up = false; 
      } 
      if(key == downKey){ 
       down = false; 
      } 
      if(key == leftKey){ 
       left = false; 
      } 
      if(key == rightKey){ 
       right = false; 
      } 
     } 

     public void keyTyped(KeyEvent x){ 

     } 

     @SuppressWarnings("unused") 
     public void actionPerformed(ActionEvent x){ 

     } 

    } 

    public void tick(){ 
     if(up){ 
      ym = -4; 
      xm = 0; 
     } 
     if(down){ 
      ym = 4; 
      xm = 0; 
     } 
     if(left){ 
      xm = -4; 
      ym = 0; 
     } 
     if(right){ 
      xm = 4; 
      ym = 0; 
     } 

     x += xm; 
     y += ym; 

     //System.out.println(x + ", " + y); 

     if(this.y <= 25) y = 25; 
     if(this.y >= caller.getHeight() - 10) y = caller.getHeight() - height; 
     if(this.x <= 0) x = 0; 
     if(this.x >= caller.getWidth() - 10) x = caller.getWidth() - height; 
    } 

    public void render(Graphics g){ 
     g.drawString(name, (x + width/2) - g.getFontMetrics().stringWidth(name)/2, y); 
     g.fillOval(x , y, width, height); 
    } 

} 

Answer 1

Как отмечает JB Nizet, его трудно, чтобы помочь по крайней мере без пример рабочего кода. Но вот моя трещина. Похоже, вы можете рассмотреть возможность применения шаблона наблюдателя. Java предоставляет интерфейс Observer и класс Observable, чтобы сделать это, но вам не нужно их использовать.

Вот ссылки на JavaDocs для объектов Java Observer и Observable, для вас учиться, в случае, если вы хотите, чтобы реализовать те:

Observer JavaDoc, Observable JavaDoc

И ссылка на в глубине учебник по теме:

Observer and Observable tutorial

Вот очень простофиля пример наблюдаемого класса и класс наблюдателя. Есть много вещей, которые необходимо принять во внимание, которых нет в этом примере. Это только для иллюстрации концепции:

public class MyObservableObject { 
    private Collection<MyObserverObject> registeredObservers; 
    private String previousValue; 
    private String observedValue; 
    private boolean isChanged; 

public D(String observedValue) { 
    this.observedValue = observedValue; 
    registeredObservers = new LinkedList<MyObserverObject>(); 
    isChanged = false; 
} 

public boolean hasChanged() { return isChanged; } 

private void setChanged() { 
    isChanged = previousValue != null && 
       !previousValue.equalsIgnoreCase(observedValue); 
} 

public void setObservedValue(String observedValue) { 
    previousValue = this.observedValue; 
    this.observedValue = observedValue; 
    setChanged(); 
    notifyObservers(); 
} 

public String toString() { return observedValue; } 

public void addObserver(MyObserverObject observer) { 
    registeredObservers.add(observer); 
} 

public void removeObserver(MyObserverObject observer) { 
    registeredObservers.remove(observer); 
} 

public void notifyObservers() { 
    for (MyObserverObject ob : registeredObservers) { ob.notify(this); } 
} 
} 

Это довольно простая установка:

• Значение, которое мы хотим отслеживать является String observedValue
• Collection<MyObserverObject> registeredObservers является довольно очевидно. Он будет содержать любые и все объекты-наблюдатели, которые наш пользовательский наблюдаемый объект будет уведомлять всякий раз, когда observedValue изменяется по звонкам на setObservedValue(String).
• addObserver(MyObserverObject), removeObserver(MyObserverObject) и notifyObservers() вся ручка добавляет (регистрирует), удаляет (отменяет регистрацию) и уведомляет обо всех наблюдателях изменений соответственно.

Итак, давайте рассмотрим простой MyObserverObject, который работает с нашей наблюдаемой:

общественного класса MyObserverObject { частная строка valuedWatched;

public MyObserverObject() { valuedWatched = null; } 

public void notify(MyObservableObject observed) { 
    if (observed.hasChanged()) updateMyValueWith(observed); 
} 

private void updateMyValueWith(MyObservableObject observed) { valuedWatched = observed.toString(); } 

public String toString() { return valuedWatched; } 
} 

Этот пример очень прост. Всякий раз, когда экземпляр MyObservableObject называет его notifyObservers(), он будет вызывать метод notify(MyObservableObject) всех MyObserverObject s, содержащийся в Collection registeredObservers. В этом примере я написал метод, который проверяет, что MyObservableObject изменился, и если hasChanged() возвращает значение true, экземпляр MyObserverObject вызовет метод updateMyValueWith(MyObservableObject).

Теперь, вот оно в действии:

public class App { 
public static void main(String[] args) { 
    MyObservableObject myOb = new MyObservableObject("Bob"); 
    MyObserver ob = new MyObserver(); 
    System.out.println(myOb + " " + ob); 
    myOb.addObserver(ob); 
    d.setObservedValue("Dave"); 
    System.out.println(myOb + " " + ob); 
} 
} 

Выход:

Bob null 
Dave Dave 

Я не знаю, если я могу объяснить этот пример больше, чем он объясняет себя :).

Я не уверен, что необходимо пройти ручную прогулку, но я надеюсь, что это поможет. Я оставил некоторые вещи из этого объяснения, но это по существу то, как работает наблюдатель. Таким образом, один класс может очень быстро оценивать значения в другом.