My "Main" class wants to act as "manager" for two objects. How do I do this cleanly?

[John Alcher Doloiras]

Sorry for the title, I don't really know the proper terms to summarize my situation.

Premise: I have an application that tracks scores for two Basketball (3x3) teams. On the "main" class, I instantiate two Team objects to represent the competing teams. Then I bind the UI elements (Buttons and TextViews) to their respective methods. See my stellar UI for context

public class MainActivity extends AppCompatActivity {

    private Team homeTeam;
    private Team awayTeam;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);


        homeTeam = new Team(
                (TextView) findViewById(R.id.home_score_text_view),
                (TextView) findViewById(R.id.home_foul_text_view),
                (TextView) findViewById(R.id.home_penalty_view)
        );
        awayTeam = new Team(
                (TextView) findViewById(R.id.away_score_text_view),
                (TextView) findViewById(R.id.away_foul_text_view),
                (TextView) findViewById(R.id.away_penalty_view)
        );

        /** Home team buttons. */
        Button homeInsideScore = (Button) findViewById(R.id.home_score_inside);
        homeInsideScore.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                homeTeam.scoreInside();
            }
        });

        Button homeOutsideScore = (Button) findViewById(R.id.home_score_outside);
        homeOutsideScore.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                homeTeam.scoreOutside();
            }
        });

        Button homeFreeThrow = (Button) findViewById(R.id.home_score_free);
        homeFreeThrow.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                homeTeam.scoreFreeThrow();
            }
        });

        Button homeFoul = (Button) findViewById(R.id.home_foul);
        homeFoul.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                homeTeam.commitFoul();
            }
        });
        /** End of Home Team buttons. **/

        /** Away Team Buttons **/
        Button awayInsideScore = (Button) findViewById(R.id.away_score_inside);
        awayInsideScore.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                awayTeam.scoreInside();
            }
        });

        Button awayOutsideScore = (Button) findViewById(R.id.away_score_outside);
        awayOutsideScore.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                awayTeam.scoreOutside();
            }
        });

        Button awayFreeThrow = (Button) findViewById(R.id.away_score_free);
        awayFreeThrow.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                awayTeam.scoreFreeThrow();
            }
        });

        Button awayFoul = (Button) findViewById(R.id.away_foul);
        awayFoul.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                awayTeam.commitFoul();
            }
        });
        /** End of Away Team Buttons. **/

    }

}

(I feel like the implementation details of Team is not necessary for the discussion) Anyway, my problem is implementing a way to track the winner. The fouls, scores, and penalty are calculated independently between teams. Therefore I could just pass a TextView as a dependency on the Team class, delegating the updating of the UI to the Team class itself. As for determining the winner, the calculation is based on each team's scores. I can't think of a clean way for the MainActivity class to solve my problem.

Any tips? Thanks in advance!

[Campbell Ritchie]

Welcome to the Ranch

I am afraid Iit rather looks as if you had gone around it the wrong way. You give the impression of writing code before you have planned what to write. I think you need a plan for what the game is going to do, completely devoid of programming terms or names of classes. You shouldn't even think of a GUI until after you have got the logic (the game classes working). I suggest you write down the description of what the game is all about. Then you can draw a diagram showing the different classes you are going to write. I would have thought, if you have Game, Team, and Score, you might have a public interface on the Game class including this sort of method:-

// ...
public void startGame() // ...
public void finishGame() // ...
public void scoreHomeGoal() // ...
public void scoreAwayGoal() // ...
public void sufferHomePenalty() // ...
public void sufferAwayPenalty() // ...
public Score getHomeScore() // ...
public Score getAwayScore() // ...
public Team getWinningTeam() // ... Not to be called before game finishes
// etc etc

Once you have got that all working without a GUI, you can add a GUI atop it. Don't start writing FXML or similar until you have it all working. Maybe you should have all actions by both teams called from methods of the Game class.
I think people shouldn't think in terms of main class (even though NetBeans always seem to create a class of that name). I think you want a very short and simple main method(), like this:-

public class GameStarter
{
   public static void main(String... args)
   {
      new Game(...).startGame();
   }
}

You will have to change that if you are working in a class which extends Application.

[John Alcher Doloiras]

Thank you for the warm welcome!

I think people shouldn't think in terms of main class..

Yeah, what I meant on that was the Main class being the main class that handles the state for both Team objects. (This is an Android app, btw).

Anyway, I think that your point on writing the whole app without a GUI first is a great idea. I'd do that and report back

[Campbell Ritchie]

John Alcher Doloiras wrote:Thank you for the warm welcome!

that's a pleasure

. . . the Main class . . . handles the state for both Team objects.

There is a simple solution: call the class Game and we shall be in agreement.

(This is an Android app, btw).

Sorry; I mistook it for FX. I shall add you to the Android forum.

Anyway, I think that your point on writing the whole app without a GUI first is a great idea. . . .

That is the usual advice, and the way I was taught to write GUI applications. Looking forward to the feedback.

[Prasad Saya]

This is an idea I have.

You may consider a winner button and its action, to determine and show the winner. This button's listener has logic to arrive at the winning team, based on the score (or its calculation).

So in the MainActivity class, within this winner button's listener:

TextView scoreHomeText = (TextView) findViewById(R.id.home_score_text_view);
TextView scoreAwayText = (TextView) findViewById(R.id.away_score_text_view);

- Get the home and away's corresponding integer score values.
- Figure who's the winner (all your complex calculations here).
- Display the winner's name, etc in the appropriate text view...

[Campbell Ritchie]

Good idea; what would happen if you click the winner button before the game has finished?

[Prasad Saya]

what would happen if you click the winner button before the game has finished?

Can change the button name to: Game complete/end/over; something like that. And then the winner team name can be displayed when the game is over.  I think that's pretty much within the scope of the app.

The new Game Done button can be placed between the Time Expired and Reset Scores buttons.

[John Alcher Doloiras]

Hello!

That "winner button" is essentially what the "TIME EXPIRED" button does (or supposed to, its not yet implemented) in my app. (See UI). Basically in 3x3 basketball, if the time expires, the team with the most points wins. But another way of winning is getting to 21 points first (which is my core problem -- how would the Game class be notified if a team reaches 21). I'm still working on my code

[Campbell Ritchie]

Try researching the observer pattern.

[Prasad Saya]

John Alcher Doloiras wrote:Hello! But another way of winning is getting to 21 points first (which is my core problem -- how would the Game class be notified if a team reaches 21).

Take a look at: TextView's addTextChangeListener method and TextWatcher.

The definition from Android API: addTextChangedListener(TextWatcher watcher)
Adds a TextWatcher to the list of those whose methods are called whenever this TextView's text changes.

Here is a possibility. When the score text view changes (gets updated/changed and displayed), the listener attached to the score can - arrive at the winner and display.

[Prasad Saya]

Continuing from the previous message...
Note that in TextWatcher interface there are three methods to be overridden. The code related to arriving at the winner and displaying it need to be in the onTextChanged() method. The other methods (afterTextChanged and beforeTextChanged) can be empty, without any code.

[John Alcher Doloiras]

Hello guys! I tried to implement my 3x3 app with the Observable pattern. Did I got the gist of the pattern right? Here's the repo

I'm currently working on the Android version with Prasad Saya's suggestions

[Campbell Ritchie]

Please post the code; many people are reluctant to look in unfamiliar repositories.

[Prasad Saya]

John Alcher Doloiras wrote:Hello guys! I tried to implement my 3x3 app with the Observable pattern. Did I got the gist of the pattern right?

Here is a blog post I had written sometime back, but it uses a Java Swing GUI example. It will give you an idea how the Observer and Observable can be used within a GUI application:
Java Swing Example using Observer and Observable

[John Alcher Doloiras]

The "entry point" of the app.

public class _3x3ScoringApp {

    public static void main(String[] args) {
        Game game = new Game();
        game.start();
        
        // For demonstration purposes only.
        // With a UI to work with, these methods
        // are bound to UI events.
        
        for (int i = 0; i < 5; i++) {
            game.awayCommitFoul();
        }
        
        for (int i = 0; i < 21; i++) {
            game.homeScoreInside();
        }
        
    }
    
}

Game.java

public class Game implements Observer {
    private final int WINNING_SCORE = 21;
    Team homeTeam;
    Team awayTeam;
    
    public Game() {
        homeTeam = new Team("HOME");
        awayTeam = new Team("AWAY");
    }
    
    /**
     * Putting that shiny Observer pattern to use.
     * Should this be moved to the constructor?
     * 
     */
    public void start() {
        homeTeam.addObserver(this);
        awayTeam.addObserver(this);
        
        // This is also where I bind UI elements.
    }


    /**
     * With a proper GUI, this method hooks up with UI
     * elements and updates them on special events such
     * as a team going penalty or a team winning the match.
     * 
     * @param name
     * @param score
     * @param fouls 
     */
    @Override
    public void update(String name, int score, int fouls) {
        if (score >= WINNING_SCORE) {
            System.out.printf("%s wins with a score of %d\n", name, score);
        } else if (fouls >= 5) {
            System.out.printf("%s is in penalty with %d fouls\n", name, fouls);
        }
    }
    
    // The code below kinda smells coz of the repetition.
    // Any cleaner way to do this?
    
    public void awayScoreInside() {
        awayTeam.scoreInside();
        // Update UI
    }
    
    public void awayScoreOutside() {
        awayTeam.scoreOutside();
        // Update UI
    }
    
    public void awayScoreFreeThrow() {
        awayTeam.scoreFreeThrow();
        // Update UI
    }
    
    public void homeScoreInside() {
        homeTeam.scoreInside();
        // Update UI
    }
    
    public void homeScoreOutside() {
        homeTeam.scoreOutside();
        // Update UI
    }
    
    public void homeScoreFreeThrow() {
        homeTeam.scoreFreeThrow();
        // Update UI
    }
    
    public void awayCommitFoul() {
        awayTeam.commitFoul();
    }
    
    public void homeCommitFoul() {
        homeTeam.commitFoul();
    }
}

Team.java

import java.util.ArrayList;

public class Team implements Observable {
    private final int INSIDE_GOAL = 1;
    private final int OUTSIDE_GOAL = 2;
    private final int FREE_THROW = 1;
    
    private final ArrayList<Observer> subscribers = new ArrayList<>();
    
    private final String name;
    private int score = 0;
    private int fouls = 0;
    
    public Team(String name) {
        this.name = name;
    }
    
    
    @Override
    public void addObserver(Observer o) {
        subscribers.add(o);
    }

    @Override
    public void removeObserver(Observer o) {
        subscribers.remove(o);
    }

    @Override
    public void notifyObserver() {
        for (Observer o : subscribers) {
            o.update(name, score, fouls);
        }
    }
    
    // The code below smells as well.
    // notifyObserver() is called 4 times.
    // Any way to clean this up?
    
    public void scoreInside() {
        score += INSIDE_GOAL;
        notifyObserver();
    }
    
    public void scoreOutside() {
        score += OUTSIDE_GOAL;
        notifyObserver();
    }
    
    public void scoreFreeThrow() {
        score += FREE_THROW;
        notifyObserver();
    }
    
    public void commitFoul() {
        fouls++;
        notifyObserver();
    }

}

Observable.java

import java.util.ArrayList;

public interface Observable {
    public void addObserver(Observer o);
    public void removeObserver(Observer o);
    public void notifyObserver();
}

Observer.java

/**
 * On hindsight, I think I should have made a 
 * "GameObserver" class that extends the classic 
 * Observer class. That way I don't explicitly 
 * pass the parameters on the update method on 
 * this Observer class.
 * 
 */
public interface Observer {
    public void update(String name, int score, int fouls);
}