Object initialization (Java)

Question

Say you have a class called team:

public class Team {

    public void Team() {
        Player player1 = new Player();
        Player player2 = new Player();

        if (player1.getName == "") {
            player1.setName = console.next();
        }

        else if (player2.getName == "") {
            player2.setName = console.next();
        }

    }
}

And another class called player:

public class Player {
    private String name;

    public void setName(String inputName) {
        name = inputName;
    }

    public String getName() {
    return name;
    }
}

If I wanted to set a name for player1, I could do so by calling the Team() method. But if I then want to set a name for player2, it's going to reset the name of player 1 as it is making a fresh player1 and player2 object each time the method is called, right?

So my question is, if I want to only initialize the player1 and player2 objects the first time I run the Team() method, how would I achieve that? Because if I moved the object initializations out of the Team class, I wouldn't have access to getName and setName.

I'm quite new to this so any help such as an alternate way of achieving this (without the use of arrays) would be greatly appreciated! Thanks.

you don't ask for console input while in the constructor stage. set apart methods to do so — svarog, May 03 '15 at 07:14
Aside from the syntax errors and the string comparison using == ([don't do that](http://stackoverflow.com/questions/513832/how-do-i-compare-strings-in-java)) it seems to me that you need to think about what the *state* of a team is. Currently you've got *local* variables in your `Team` constructor... you should have *instance* variables. — Jon Skeet, May 03 '15 at 07:14
Jon, I think he needs a mediator class that brings `Team` and `Player`s into relation by instantiating `Player`s and then adding them to the `Team`. (Sounds logical to me.) But of course, the TO should think about the relations. — try-catch-finally, May 03 '15 at 07:32

score 1 · Accepted Answer · answered May 03 '15 at 07:14

You should understand the relation between a Team and a Player.

In your current implementation, a Team have two Players, I would move the initialization to a constructor:

public class Team {

    private Player player1;
    private Player player2;

    public Team(Player player1, Player player2) {
        this.player1 = player1; 
        this.player1 = player2;   
    }
}

The initialization of player1 and player2 should be done in some driver, a class that should be responsible of initializing Players and setting them to a team.

Setting/getting the player's name should be done in the Player class, not in the Team class, as Team is only responsible for the team, not for the Players details.

I would change Team class to contain X Players and not only 2, it'll be easier to expand this class in the future.

Important note: Use equals to compare Strings, == compares references and not String's content.

svarog · Answer 2 · 2015-05-03T08:25:11.450

public class Team {

Player player1, player2;

public void Team() {
    player1 = new Player();
    player2 = new Player();
}

public void Team(Player p1, Player p2) {
    player1 = p1;
    player2 = p2;
}

public void setPlayer1(String name) {    
    if (!name.isEmpty()) {
        player1.setName = name;
    }
}

public void setPlayer2(String name) {    
    if (!name.isEmpty()) {
        player2.setName = name;
    }
}

public String getPlayer1Name() {
    get player1.getName();
}

public String getPlayer2Name() {
    get player2.getName();
}

then do something like

Team team = new Team();
team.setPlayer1("john");
team.setPlayer2("jane");

or

Team team = new Team("john", "jane");

that's how you would properly write the code,

player1 and player2 are still local variables to the constructor in your code — Niklas R, May 03 '15 at 08:23

Peter Lawrey · Answer 3 · 2015-05-03T07:25:09.387

0

If you assume a Team could have any number of Players and you build up a team by adding players, you can write it this way.

public class Team {
    private final List<Player> players = new ArrayList<>();
    public void add(Player player) { players.add(player); }
}

public class Player {
    final String name;
    public Player(String name) { this.name = name; }
    public String getName() { return name; }
}

// in your main or another method.
Team team = new Team();
while(/* more players */) {
    team.add(new Player(console.next()));
}

This way you can add any number of players for each name you read in.

edited May 03 '15 at 07:25

answered May 03 '15 at 07:20

Peter Lawrey

525,659
79
751
1,130

Unless we live in a world with clones, shouldn't `players` be a `Set`? :) – Chetan Kinger May 03 '15 at 07:22
@ChetanKinger possibly, but order seems to matter. Perhaps it shouldn't in which case a `Set` would be better. Also you could have two players called `"John"` – Peter Lawrey May 03 '15 at 07:24
1

A `LinkedHashSet` then? Best of both worlds? – Chetan Kinger May 03 '15 at 07:25
@ChetanKinger true, but since we haven't implemented `equals` and `hashCode` .... – Peter Lawrey May 03 '15 at 07:26
Ideally, each player in a `Team` should have a `name` and a `number` and that's what `equals` and `hashCode` should be based on. – Chetan Kinger May 03 '15 at 07:27
1

@ChetanKinger true, although the number should be assigned automatically. It is possible this answer is already too complicated for the OP. See the accepted answer. ;) – Peter Lawrey May 03 '15 at 07:30
1

Agreed that this answer and our discussion is probably beyond the level the OP is at the present. – Chetan Kinger May 03 '15 at 07:36

Object initialization (Java)

3 Answers3