Question

我最近才开始学习java而且遇到了一个问题。我有一些通过类构造函数创建的对象，我想在不同的类中使用这些声明的对象。对象的内容通过变量设置。

所以一个简单的解决方案是将变量设置为静态，然后通过执行（仅作为示例）在另一个类中调用它们

 Originalclass.staticVariable

并将其用作我的参数。

所以假设我的原始类是Firstclass，我想要创建的对象叫做superObject，而我想在我的对象中应用的变量叫做variableIneed。如果我要在另一个类中创建我的对象，我会输入

 Firstclass superObject = new Firstclass(Firstclass.variableIneed);

这有效，但我想知道，是否可以在原始类中创建对象，然后在不同的类中使用它？这样做会有好处吗？

如果这是一个重复的问题或者不够具体，我很抱歉，这是我的第一篇文章。：）

如果我的代码有助于回答我的问题，我会很乐意提出这个问题，但我觉得这与我的代码没问题有什么关系。

Answer 1

您正在使用与构造函数参数相同的类创建一个静态变量的Firstclass，这对我没有任何意义。您可以在Firstclass类中使用该变量而不将其作为参数获取，它已经可以访问它。对于你的主要问题，我认为你想要的是这样的：

class Firstclass{
  private String someString = "";

  public void createString(String myString){
    someString = myString;
  }

  public String getSomeString(){
    return someString;
  }
}

class Original{
  public void sometMethod(Firstclass first){
    //using someString from 'first'
    System.out.println(first.getSomeString());  
  }
}

Answer 2

我喜欢这个问题，因为它问“有没有更好的方法来做到这一点？”

听起来你有一种情况，你有一些价值，我们假设一个整数，将用于几个对象。 “我应该复制这个值，还是应该使用相同的值？”是一个重要的问题。

假设字符串是多个位置使用的字符串，并且不会在应用程序的生命周期中发生变化，但您希望在一个位置灵活地更改字符串的内容。例如，如果您正在构建游戏，那么您允许用户使用的生命数可能是整个应用程序中使用的整数。一个好的模式是constant。例如：

public interface ApplicationConstants {
    public static Integer PLAYER_LIVES_COUNT = 3;
}

然后任何需要常量的类都可以简单地实现常量接口：

public class Application implements ApplicationConstants {

    public static void main(String[] args) {
        FirstClass firstClass = new FirstClass(PLAYER_LIVES_COUNT);
        FirstClass superObject = new FirstClass(PLAYER_LIVES_COUNT);
    }
}

这是比您的应用程序周围的数字硬编码更好的模式，因为您有一个地方可以控制这个数字。没有“找到并替换。”

如果FirstClass对象本身是一个将在应用程序周围使用的对象，该怎么办？它有多个属性，其他类需要访问您的应用程序。在这种情况下，一个好的模式是singleton pattern。

公共决赛班FirstClassFactory {

private static FirstClass instance = null;
private FirstClassFactroy() {
}

public static synchronized Singleton getInstance() {
    if (instance == null) {
        instance = new FirstClass();
    }
    return instance;
}

}

然后围绕您的应用程序，您可以在运行时更改FirstClass实例的值，并且对于使用FirstClass的任何对象，值都将更改：

public class Application {
    public static void main(String[] args) {
        FirstClass firstClass = FirstClassFactory.getInstance();

        firstClass.setPlayerLives(3);
    }
}

如果应用程序中的另一个类调用FirstClassFactory.getInstance()，它将收到已将playerLives设置为3的实例。

最后，假设您有一个用例，您需要向FirstClass对象添加更多数据和功能。一个好的模式可能是扩展名或wrapper or decorator pattern。例如：

public class LivesManager {

    private FirstClass firstClass;
    private String statusMessage = "Number of lives remaining: ";

    public LivesManager(FirstClass firstClass) {
        this.firstClass = firstClass;
    }

    public void decrementRemainingLives() {
        --firstClass.getLives();
    }

    public String getLivesMessage() {
        return statusMessage + firstClass.getLives();
    }
}

最后一点：正如评论中所提到的，最好将类变量设为私有，并使用getter和setter来获取对变量的访问权限。例如：

public class FirstClass {

    private Integer lives;

    public FirstClass(Integer lives) {
        this.lives = lives;
    }

    public Integer getLives() {
        return lives;
    }

    public void setLives(Integer lives) {
        this.lives = lives;
    }
}

希望这有帮助，祝你好运！

Answer 3

如果你在一个类中创建一个对象，你通常不想通过简单地将它作为static来“共享创建的对象”（特别是当你不确定静态意味着什么时）。

不要滥用static。 static成员实际上属于类本身而不是特定对象。因此，在开始将变量声明为static之前，您要考虑它是属于该类的属性吗？或者它是属于个别对象的属性？

所有对象之间共享更多static个变量。（你只有一份副本）。因此，如果您在许多其他类中共享它，它的值可能会从您“共享”它的任何类中改变，从而使您的类紧密耦合（并且您希望阻止它）。

除非对象属于该类，并且它可能是常量（声明为final），否则您可能不希望通过将其声明为static来共享它。

这有效，但我想知道，是否可以在原始类中创建对象，然后在不同的类中使用它？这样做会有好处吗？

如果我是你，如果我需要与其他类“共享”我的对象，我将通过一个方法（一个getter方法）传递它。

<强>〔实施例：

class Car{
    private Engine engine;

    //Constructor not shown

    //a getter method
    public getEngine(){
        return engine;
    }
}

class Runner{
    public static void main(String[] args){
        Car c = new Car();
        Engine engine = car.getEngine();  //retrieve engine from car (for whatever use)
    }
}

Answer 4

“这有用，但我想知道，是否可以在原始类中创建对象然后在另一个类中使用它？这样做有什么好处？”

是的，有可能。我将举例说明一个简单的例子：

A类：

在其中定义了Random对象（Random rand = new Random（）;）。通常使用getter方法调用getRandomizer（）;

public Random getRandomizer(){
  return rand;
}

B类：

B类可以实例化A类。

A _object = new A();

随机对象是在A类中创建的，但之后在B类中实例化A类，我们现在可以访问一般的公共方法。

我们现在可以通过以下方式简单地访问Random对象：

_object.getRandomizer();

（_ object只是我定义的变量名。）

我可以在不同的类中使用声明的对象而不再声明对象吗？

4 个答案: