Java 从父类访问变量

gameServer.java：

import java.util.ArrayList;

public class gameServer{

    public static server server;
    public static gameRunner gameRunner;
    public static ArrayList<packet> packets = new ArrayList<packet>();

    public static void main(String[] args) throws Exception {
        server = new server();
        server.startServer(5050);
        Runnable listenServer = new Runnable() {
            public void run() {
                while(true) {
                    packets.add(server.getPacket());
                }
            }
        };
        new Thread(listenServer).start();
        gameRunner = new gameRunner();
        while(true) {
            if(packets.size() <= 0)
                continue;
            gameRunner.executeMessage(packets.get(0));
            packets.remove(0);
        }
    }
}

public class gameServer{
  /* ... */
  public static void main(String[] args) throws Exception {
    /* ... */
    gameRunner = new gameRunner();
    gameRunner.gameServer = server;
    /* ... */
  }
}

import java.util.ArrayList；
公共类游戏服务器{
公共静态服务器；
公共静态gameRunner gameRunner；
公共静态ArrayList数据包=新建ArrayList（）；
公共静态void main（字符串[]args）引发异常{
服务器=新服务器（）；
startServer（5050）；
Runnable listenServer=new Runnable（）{
公开募捐{
while（true）{
packets.add（server.getPacket（））；
}
}
};
新线程（listenServer.start（）；
gameRunner=新gameRunner（）；
while（true）{
if（packets.size（）
应该这样做。但是，如果您可以描述您试图实现的目标，这将非常有用，因为使用构造函数设置的静态变量（这是您在
B
中使用
num
所做的）很可能不是一个好主意。此外，因为您使用的是“父”一词，听起来好像您打算进行继承，但代码示例没有任何继承

应该这样做。但是，如果您可以描述您试图实现的目标，这将非常有用，因为使用构造函数设置的静态变量（这是您在
B
中使用
num
所做的）很可能不是一个好主意。此外，因为您使用的是“父”一词，听起来像是要执行继承，但代码示例没有任何继承。
在B中创建一个getter方法，
getNum（）{return num；}
，然后调用
B.getNum（）
在C中。我不确定对B的引用来自何处。C不扩展B，这是您的意图吗？
在B中创建一个getter方法，
getNum（）{return num；}
，并调用
B.getNum（）
在C中。我不确定对B的引用是从哪里来的。C不扩展B，这是你的意图吗？
EDIT1猜对了：）

关于设计的几句话：


大多数这些静态都很糟糕，只有当属性是类的一部分（例如默认值、业务）时，以及当你真的喝醉了、懒散时，才应该将它们设置为静态-但这是另一个主题（如果你继续编码，你就会掌握其中的诀窍）

实际上，您不应该将属性公开，它们应该始终是私有的或受保护的，并使用公共getter/setter方法-这样您可以限制对属性的访问，并可以控制get或set上发生的事情。（但在java中，这往往非常乏味）


现在，保持静态，您可以很容易地发送这样的消息（在sendPlayerPackets.run（）中）：
server.sendPacket（player[0].packet）；

要将服务器传递给gameRunner，您需要执行以下操作：

（在gameRunner.java中）

旧零件

纯粹出于本能，我想你想要这个：

public class A {
    public B foo;
    public C bar;

    public A() {
      // java does not like exposing this, but screw that
      foo = new B(this, 10);
      C = new C(this);
    }
}

public class B {
    private A parent;
    public int numB;

    public B(A parent, int num) {
      this.parent = parent;

      numB = num;
    }
}

public class C {
    private A parent;
    public int numC;

    public C(A parent) {
      this.parent = parent;

      if(parent != null && parent.B != null)
        numC = parent.B.numB;
    }
}

简而言之：您必须将父对象传递给子对象，子对象才能访问它

请注意，在本例中，B必须在C之前初始化，为了避免这个问题，我想你需要一些事件。无论如何，这个想法似乎没有很好的定义，你应该再次考虑你想要完成什么（并告诉我们）。
EDIT1猜对了：）

关于设计的几句话：


大多数这些静态都很糟糕，只有当属性是类的一部分（例如默认值、业务）时，以及当你真的喝醉了、懒散时，才应该将它们设置为静态-但这是另一个主题（如果你继续编码，你就会掌握其中的诀窍）

实际上，您不应该将属性公开，它们应该始终是私有的或受保护的，并使用公共getter/setter方法-这样您可以限制对属性的访问，并可以控制get或set上发生的事情。（但在java中，这往往非常乏味）


现在，保持静态，您可以很容易地发送这样的消息（在sendPlayerPackets.run（）中）：
server.sendPacket（player[0].packet）；

要将服务器传递给gameRunner，您需要执行以下操作：

（在gameRunner.java中）

旧零件

纯粹出于本能，我想你想要这个：

public class A {
    public B foo;
    public C bar;

    public A() {
      // java does not like exposing this, but screw that
      foo = new B(this, 10);
      C = new C(this);
    }
}

public class B {
    private A parent;
    public int numB;

    public B(A parent, int num) {
      this.parent = parent;

      numB = num;
    }
}

public class C {
    private A parent;
    public int numC;

    public C(A parent) {
      this.parent = parent;

      if(parent != null && parent.B != null)
        numC = parent.B.numB;
    }
}

简而言之：您必须将父对象传递给子对象，子对象才能访问它

请注意，在本例中，B必须在C之前初始化，要解决这个问题，我想你需要一些事件。无论如何，这个想法似乎没有很好的定义，你应该再次考虑一下你想要完成什么（并告诉我们）。
我正在一个游戏服务器上工作，我有一个“main”类，其中有一个对象“UdpServer”，还有一个“playerController”，我想从对象“playerController”中使用UdpServer的发送函数。“UdpServer”有一个打开的UDP套接字，该套接字卡在端口上。因此我无法创建“UdpServer”的新实例，我需要使用“main”类中的实例。@PatrickLorio:我想我理解-So
main
（对应于
a
）包含一个静态的
UdpServer
（对应于
B
），您希望从
playerController
（它是
C
的一个实例）访问该服务器您应该使用实际的类名，这样会使您的情况更容易理解。然后，我所显示的代码应该工作。但是，谨防静态实例常常使代码变得不可测试；您应该考虑将<代码> UDPServer < /C>作为参数传递给<代码> PrreReals< <代码>构造器。我和一个gameserver有一个“main”类和一个对象“UdpServer”，还有一个“playerController”，我想使用对象“playerController”中UdpServer的发送函数。“UdpServer”有一个打开的UDP套接字，它被固定在一个端口上。因此我无法创建“UdpServer”的新实例，我需要使用“main”中的一个实例类。@Patrickorio:我想我明白了-所以
Main
（对应于
A
）包含一个静态

public class gameRunner {
  public static ArrayList<object> objects = new ArrayList<object>();
  public static player[] players = new player[1000];

  public server gameServer;

  /* ... */
  Runnable sendPlayerPackets = new Runnable () {
    public void run () {
        while(true) {
            gameServer.sendPacket(gameRunner.players[0].packet); //<<<----
            }
    }
};

public class gameServer{
  /* ... */
  public static void main(String[] args) throws Exception {
    /* ... */
    gameRunner = new gameRunner();
    gameRunner.gameServer = server;
    /* ... */
  }
}

public class A {
    public B foo;
    public C bar;

    public A() {
      // java does not like exposing this, but screw that
      foo = new B(this, 10);
      C = new C(this);
    }
}

public class B {
    private A parent;
    public int numB;

    public B(A parent, int num) {
      this.parent = parent;

      numB = num;
    }
}

public class C {
    private A parent;
    public int numC;

    public C(A parent) {
      this.parent = parent;

      if(parent != null && parent.B != null)
        numC = parent.B.numB;
    }
}