Java 如何跟踪变量'；来自另一个类的值

我正在为我的游戏创建一个

Player

类，我需要一些方法来跟踪控件，但我希望将键盘与Player hitbox/rendering类分开跟踪。我已经设置了代码来存储某些键的值（W、A、S、D和▲,◄,▼,►) 在变量中，在我的主类中。我想以某种方式指向构造函数中的变量，并以某种方式跟踪它们

解决此问题的一种方法是将变量

w

替换为

player2.up

等等，因此我的键盘跟踪方法直接编辑

Player

对象，但这没有那么灵活。我也可以将调用对象传递给构造函数，但这更不灵活。我必须从现在在player类中，但是以某种方式引用变量会非常酷

我必须同时传递

keylister

接口提供的常量，但代码如下：

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);
    }

}

套装学习游戏编程；
导入java.awt.Component；
导入java.awt.Dimension；
导入java.awt.Graphics；
导入java.awt.Point；
导入java.awt.Rectangle；
导入java.awt.event.ActionEvent；
导入java.awt.event.KeyEvent；
导入java.awt.event.KeyListener；
公共类播放器扩展矩形{
私有静态最终长serialVersionUID=6027220656827265195L；
int向上键；
int键；
int leftKey；
int-rightKey；
布尔向上；
布尔向下；
布尔左；
布尔右；
int-ym；
int-xm；
键盘跟踪器；
组件调用程序；
字符串名；
公共玩家（）{
//TODO自动生成的构造函数存根
}
公共播放器（矩形r）{
超级（r）；
//TODO自动生成的构造函数存根
}
公共玩家（p点）{
超级（p）；
//TODO自动生成的构造函数存根
}
公共播放器（维度d）{
超级（d）；
//TODO自动生成的构造函数存根
}
公共播放器（整数宽度、整数高度）{
超级（宽度、高度）；
//TODO自动生成的构造函数存根
}
公共玩家（点p，维度d）{
super（p，d）；
//TODO自动生成的构造函数存根
}
公共播放器（字符串名称、整数x、整数y、整数宽度、整数高度、整数上键、整数下键、整数左键、整数右键、组件调用者）{
超级（x、y、宽度、高度）；
this.upKey=upKey；
this.downKey=downKey；
this.leftKey=leftKey；
this.rightKey=rightKey；
this.keylister=newkeyboardtracker（）；
this.caller=caller；
caller.addKeyListener（this.keyListener）；
this.name=名称；
}
私有类KeyboardTracker实现KeyListener{
按下公共无效键（KeyEvent ke）{
int key=ke.getKeyCode（）；
如果（键==向上键）{
向上=真；
}
如果（键==向下键）{
向下=真；
}
if（key==leftKey）{
左=真；
}
如果（键==右键）{
右=真；
}
}
公开无效密钥已释放（密钥事件）{
int key=ke.getKeyCode（）；
如果（键==向上键）{
向上=错误；
}
如果（键==向下键）{
向下=假；
}
if（key==leftKey）{
左=假；
}
如果（键==右键）{
右=假；
}
}
public void keyTyped（KeyEvent x）{
}
@抑制警告（“未使用”）
已执行的公共无效操作（操作事件x）{
}
}
公共空白勾号（）{
如果（向上）{
ym=-4；
xm=0；
}
如果（向下）{
ym=4；
xm=0；
}
如果（左）{
xm=-4；
ym=0；
}
如果（右）{
xm=4；
ym=0；
}
x+=xm；
y+=ym；
//系统输出打印ln（x+“，”+y）；
如果（this.y=caller.getHeight（）-10）y=caller.getHeight（）-height；
如果（this.x=caller.getWidth（）-10）x=caller.getWidth（）-height；
}
公共空间渲染（图形g）{
g、 抽绳（名称，（x+width/2）-g.getFontMetrics（）.stringWidth（名称）/2，y）；
g、 圆角（x，y，宽度，高度）；
}
}

---

< /P> < P>正如JB Nizet所提到的，至少没有一个工作代码示例是很难帮助的。但是这里是我的破解。听起来你可能想考虑实现一个观察者模式。java提供了接口：代码>观察者< /代码>和类<代码>可观察的< /代码>，但是你不必使用它们。 以下是指向Java

Observer

和

Observable

对象的JavaDocs链接，供您学习，以防您想要实现这些：

JavaDoc， JavaDoc

以及有关该主题的深入教程的链接：

这是一个非常简单的可观察类和观察者类的示例。有许多需要考虑的事情不在本示例中。这只是为了说明概念：

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); }
}
}

这个例子非常简单。每当

MyObservableObject

的实例调用它的

notifyobservators（）

方法时，它都会调用

notify（MyObservableObject）
集合注册表中包含的所有
MyObserverObject
的方法。在本例中，我编写了一个方法来验证
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

我不知道我是否能解释这个例子，就像它解释它本身一样：）

我是
Bob null
Dave Dave