Scope issue?

Question

Folks, I have a question on scope (or at least I think it is a scope question.
Here is what I want to do. In my game class (that manages the turns and picks a winner), I want to create either a SmartPlayer or a DumbPlayer object. Both are children of Player. My first run at this ended with a scope issue which, through your suggestions, I solved. I made some changes to the code and got past it.
(code below) I created an Interface PlayerInt which has the required methods (I know in this simple program, I don't need an Interface, but I am trying to learn about them and inheritance, and other things. ).Then I defined a Player class, and SmartPlayer and DumbPlayer. Player has the private name variable and a setter to set the name properly. In the constructor for SmartPlayer and DumbPlayer, I call setName("the name").
When I run the game, I declare Player computer and then instantiate a either a SmartPlayer or DumbPlayer object and assign it to Player. Howver, computer.name is null. I don't understand why it is not being set.
        Player computer = null;
        if (generator.nextInt(2) == 0){
              computer = new SmartPlayer();
        } else {
             computer = new DumbPlayer();
        } Thanks, in advance. Oil.
relevant code below:
public interface PlayerInt {
    public int takeTurn (int stones);
    public void setName(String theName);
    public String getName ();
public class Player implements PlayerInt {
    public String getName () {
        return name;
    public void setName (String theName) {
        name = theName;
     public int takeTurn(int stones){
         return -1;
    private String name;
public class DumbPlayer extends Player {
    public void DumbPlayer () {
        setName("Dumb Player");
* Take a random number of stones that are less than or equal to 1/2 pile.
* PlayerInt must take between 1 and 1/2 stones. At 3 or less, can only take 1 stone and comply with rules.
* @param stones this is the number of stones in the pile.
* @return returns the number of stones taken.
    public int takeTurn (int stones) {
        Random generator = new Random();
        int stonesTaken = 0;
        if (stones > 3) {
            stonesTaken = generator.nextInt((1 + stones)/2);
        } else {
            stonesTaken = 1;
        return stonesTaken;
public class SmartPlayer extends Player {
    public void SmartPlayer() {
        setName("Smart Player");
     * PlayerInt takes a turn based on rules.
     * PlayerInt takes enough stones to make the pile 1 power of 2 less than 3, 3, 7, 15, 31, or 63 and less than 1/2 the pile.
     * If the pile is already 3, 7, 15, 31, or 63, take a random stone.
     * @param stones the number of stones left in the pile.
     * @return the number of stones taken.
    public int takeTurn (int stones) {
        int halfstones = stones/2;
        int stonesToTake = 0;
        switch (stones) {
            case 1:
            case 2:
            case 3:
                stonesToTake = 1;
                break;
            case 7:
            case 15:
            case 31:
            case 63:
                Random generator = new Random();
                stonesToTake = generator.nextInt(1 + halfstones);
                break;
            default:
                if (stones > 3 && stones < 7){
                    stonesToTake = stones - 3;
                } else if (stones > 7 && stones < 15) {
                    stonesToTake = stones - 7;
                } else if (stones > 15 && stones < 31) {
                    stonesToTake = stones - 15;
                } else if (stones > 31 && stones < 63) {
                    stonesToTake = stones - 31;
                }else if (stones > 63) {
                    stonesToTake = stones - 63;
        return stonesToTake;
public class Game {
    // Let player choose to play smart vs dumb, human vs computer,
    //human vs dumb, or human vs smart.
    public void playGame() {
        Pile thePile = new Pile();
        Random generator = new Random();
        int turn = generator.nextInt(2);
        HumanPlayer human = new HumanPlayer();
        boolean foundWinner = false;
        String winner = "";
        int stonesTaken;
// declare parent
        Player computer;
// instantiate and assign a SmartPlayer or DumbPlayer object to Player reference.
        if (generator.nextInt(2) == 0){
              computer = new SmartPlayer();
        } else {
             computer = new DumbPlayer();
        if (turn == 0) {
// Should print out either "Smart Player" or "Dumb Player"
            System.out.println(computer.getName() + " took the first turn. There are " + thePile.getNumberOfStones() + " stones in the pile.");
        } else {
            System.out.println("You take the first turn. There are " + thePile.getNumberOfStones() + " stones in the pile.");
        while (!foundWinner) {
            if (turn == 0) {
                stonesTaken = computer.takeTurn(thePile.getNumberOfStones());
                thePile.takeStones(stonesTaken);
                System.out.println(computer.getName() + " took: " + stonesTaken + " stones.");
                turn = 1;
            } else {
                thePile.takeStones(human.takeTurn(thePile.getNumberOfStones()));
                turn = 0;
            if (thePile.getNumberOfStones() == 0) {
                if (turn == 0) {
                    foundWinner = true;
                    winner = human.getName();
                } else {
                    foundWinner = true;
                    winner = computer.getName();
        }// end while
        System.out.println("The winner is " + winner + ".");
}

Answer 1

To be honest. I'd keep both interface and abstract class.
But instead of using a reference to the abstract class use the interface instead.
So
PlayerInt player = null;
//later
player = new DumbPlayer();This is actually the "correct" way of doing this. So basically any code that uses the PlayerInt does not actually need to know what implementation is being used. In your example this is not important since you initialize it yourself but imagine you had an APIthat exposed the computer player with a method like this...
public PlayerInt getComputerPlayer()Then other code can use this method to get a PlayerInt implementation. It won't know which one, and it won't care. And that's why this is flexible and good. Because you can add new implementations later.
The Player abstract class is actually hidden away from most code as an implementation detail. It's not great to use abstract classes as reference types because if you want to create new implementations later among other things you've boxed yourself in to a class heirarchy. But abstract classes are good for refactoring away boilerplate code, as you have already done here. There's no point in implementing get/setName over and over again so do as you have here, create an abstract class and stick the basic implementation there.
Anyway all this is akin to why it is preferrable (uj slings and arrows aside) to do things like
List<String> list = new ArrayList<String>();All you care is that you have a List (interface), you don't care what implementation (ArrayList) nor do you care that there is an abstract class (or two) that ArrayList extends.