refactor the Generic Team class as well & the best solution without casting! Type parameter T extends Player (makes the methods more restricted!)

Author: Csaba79-coder

src/main/java/bootstrap/DataLoader.java

@@ -1,5 +1,7 @@
 package bootstrap;
 
+import controller.GenericTeamController;
+import controller.GenericTeamRefactorController;
 import controller.TeamController;
 import model.type.RawTypeArrayList;
 import model.type.TypeParameterArrayList;
@@ -16,5 +18,9 @@ public void load() {
  new TypeParameterArrayList().testType();
  separator.print();
  new TeamController().createTeam();
+ separator.print();
+ new GenericTeamController().createTeam();
+ separator.print();
+ new GenericTeamRefactorController().createTeam();
  }
 }

src/main/java/controller/GenericTeamController.java

@@ -0,0 +1,24 @@
+package controller;
+
+import model.generic.*;
+
+public class GenericTeamController {
+
+ public void createTeam() {
+
+ FootballPlayer joe = new FootballPlayer("Joe");
+ BaseballPlayer pat = new BaseballPlayer("Pat");
+ SoccerPlayer beckham = new SoccerPlayer("Beckham");
+
+ // instead of T I added FootballPlayer as type argument!
+ GenericTeam<FootballPlayer> adelaideCrows = new GenericTeam<>("Adelaide Crows");
+ adelaideCrows.addPlayer(joe);
+ // adelaideCrows.addPlayer(pat);
+ // adelaideCrows.addPlayer(beckham);
+
+ System.out.println(adelaideCrows.numPlayers());
+
+ GenericTeam<BaseballPlayer> baseballTeam = new GenericTeam<>("Chicago Cubs");
+ baseballTeam.addPlayer(pat);
+ }
+}

src/main/java/controller/GenericTeamRefactorController.java

@@ -0,0 +1,22 @@
+package controller;
+
+import model.generic.*;
+
+public class GenericTeamRefactorController {
+
+ public void createTeam() {
+
+ FootballPlayer joe = new FootballPlayer("Joe");
+ BaseballPlayer pat = new BaseballPlayer("Pat");
+ SoccerPlayer beckham = new SoccerPlayer("Beckham");
+
+ GenericTeamRefactor<FootballPlayer> adelaideCrows = new GenericTeamRefactor<>("Adelaide Crows");
+ adelaideCrows.addPlayer(joe);
+
+ GenericTeamRefactor<BaseballPlayer> baseballTeam = new GenericTeamRefactor<>("Chicago Cubs");
+ baseballTeam.addPlayer(pat);
+
+ GenericTeamRefactor<SoccerPlayer> manchesterUnited = new GenericTeamRefactor<>("Manchester United");
+ manchesterUnited.addPlayer(beckham);
+ }
+}

src/main/java/model/generic/GenericTeam.java

@@ -0,0 +1,101 @@
+package model.generic;
+
+import java.util.ArrayList;
+
+public class GenericTeam<T> {
+
+ private String name;
+ int played = 0;
+ int won = 0;
+ int lost = 0;
+ int tied = 0;
+
+ private ArrayList<T> members = new ArrayList<>();
+
+ public GenericTeam(String name) {
+ this.name = name;
+ }
+
+ // T is a parameterized type
+ public boolean addPlayer(T player) {
+ if (members.contains(player)) {
+ // we make a casting down there! do not forget double brackets!
+ System.out.println(((Player) player).getName() + " is already on this team");
+ return false;
+ } else {
+ members.add(player);
+ System.out.println(((Player) player).getName() + " picked for team " + this.name);
+ return true;
+ }
+ }
+
+ public int numPlayers() {
+ return this.members.size();
+ }
+
+ public void matchResult(Team opponent, int ourScore, int theirScore) {
+ if (ourScore > theirScore) {
+ won++;
+ } else if (ourScore < theirScore) {
+ lost++;
+ } else {
+ tied++;
+ }
+ played++;
+ if (opponent != null) {
+ opponent.matchResult(null, theirScore, ourScore);
+ }
+ }
+
+ public int ranking() {
+ return ((won * 2) + tied);
+ }
+
+ public String getName() {
+ return name;
+ }
+
+ public void setName(String name) {
+ this.name = name;
+ }
+
+ public int getPlayed() {
+ return played;
+ }
+
+ public void setPlayed(int played) {
+ this.played = played;
+ }
+
+ public int getWon() {
+ return won;
+ }
+
+ public void setWon(int won) {
+ this.won = won;
+ }
+
+ public int getLost() {
+ return lost;
+ }
+
+ public void setLost(int lost) {
+ this.lost = lost;
+ }
+
+ public int getTied() {
+ return tied;
+ }
+
+ public void setTied(int tied) {
+ this.tied = tied;
+ }
+
+ public ArrayList<T> getMembers() {
+ return members;
+ }
+
+ public void setMembers(ArrayList<T> members) {
+ this.members = members;
+ }
+}

src/main/java/model/generic/GenericTeamRefactor.java

@@ -0,0 +1,101 @@
+package model.generic;
+
+import java.util.ArrayList;
+
+public class GenericTeamRefactor<T extends Player> {
+
+ private String name;
+ int played = 0;
+ int won = 0;
+ int lost = 0;
+ int tied = 0;
+
+ private ArrayList<T> members = new ArrayList<>();
+
+ public GenericTeamRefactor(String name) {
+ this.name = name;
+ }
+
+ // T is a parameterized type
+ public boolean addPlayer(T player) {
+ if (members.contains(player)) {
+ // works again because of T extends Player in the diamond!
+ System.out.println(player.getName() + " is already on this team");
+ return false;
+ } else {
+ members.add(player);
+ System.out.println(player.getName() + " picked for team " + this.name);
+ return true;
+ }
+ }
+
+ public int numPlayers() {
+ return this.members.size();
+ }
+
+ public void matchResult(Team opponent, int ourScore, int theirScore) {
+ if (ourScore > theirScore) {
+ won++;
+ } else if (ourScore < theirScore) {
+ lost++;
+ } else {
+ tied++;
+ }
+ played++;
+ if (opponent != null) {
+ opponent.matchResult(null, theirScore, ourScore);
+ }
+ }
+
+ public int ranking() {
+ return ((won * 2) + tied);
+ }
+
+ public String getName() {
+ return name;
+ }
+
+ public void setName(String name) {
+ this.name = name;
+ }
+
+ public int getPlayed() {
+ return played;
+ }
+
+ public void setPlayed(int played) {
+ this.played = played;
+ }
+
+ public int getWon() {
+ return won;
+ }
+
+ public void setWon(int won) {
+ this.won = won;
+ }
+
+ public int getLost() {
+ return lost;
+ }
+
+ public void setLost(int lost) {
+ this.lost = lost;
+ }
+
+ public int getTied() {
+ return tied;
+ }
+
+ public void setTied(int tied) {
+ this.tied = tied;
+ }
+
+ public ArrayList<T> getMembers() {
+ return members;
+ }
+
+ public void setMembers(ArrayList<T> members) {
+ this.members = members;
+ }
+}