Java Erreur de programmation

Question

Mes deux classes sont listées ci-dessous: la classe TennisTeam et la classe TennisTeamApp qui l'utilise. Il y a une erreur qui est:

Player cannot be resolved to a type 

S'il vous plaît quelqu'un peut-il me dire comment résoudre ce problème?

// Kartik Patel 
// 16/08/2013 

    public class TennisTeam{ 
    private String country; 
    public Player player1; 
    public Player player2; 

// Constructor 
    public TennisTeam(String countryIn){ 
    country = countryIn; 
    storePlayerData(country); 
    } 

// Gets and stores user name 
    public void storePlayerData(String country){ 
    String prompt = "Enter Players Name "; 
    System.out.println("Getting data from country " + country); 
    System.out.println("Player 1, " + country +": "); 
    System.out.println(readString(prompt)); 
    System.out.println("Player 2, " + country + ": "); 
    System.out.println(readString(prompt)); 
    } 

// Read Strings 
    public String readString (String prompt){ 
    java.util.Scanner keyboard = new java.util.Scanner(System.in); 
    System.out.println(prompt); 
    return keyboard.nextLine(); 
    } 

// Assessors returning values 
    public String getCountry(){ 
    return country; 
    } 
} 



public class TennisTeamApp{ 
    public ststic void main(String [] args){ 
    TennisTeam [ ] teams = { new TennisTeam("NZ"), new TennisTeam("AUS")}; 

    for (TennisTeam team: teams){ 
     System.out.println(team.getCountry() + ": "); 
     System.out.println(team.player1.getName() + ", "); 
     System.out.println(team.player2.getName()); 
    } 
} 
} 

Answer 1

Importez Player avec une instruction d'importation. La raison Player n'est pas résolue en un type car elle n'est pas connue dans les espaces de noms disponibles, donc le correctif est de l'importer.

Answer 2

Vous n'avez pas partagé la classe Player qui doit être présente afin de compiler votre classe TennisTeam car elle contient une référence à Player. Assurez-vous donc d'avoir une classe Player compilée avant d'essayer de compiler votre classe TennisTeam. Si c'est le cas, assurez-vous de l'avoir importé dans votre classe TennisTeam.

Un autre problème dans votre code est que vous n'avez pas initialisé vos objets Player lors de l'initialisation de votre objet TennisTeam. Par conséquent, vous courrez dans exception de pointeur NULL en accesing l'objet joueur dans la ligne:

System.out.println(team.player1.getName() + ", "); 

Answer 3

Kartik,

Pour une raison que j'aime faire les débutants au niveau des problèmes de devoirs si bien que si vous (OP) sont Assez stupide pour le faire passer pour votre propre travail, alors vous serez surpris à tricher à coup sûr (sauf si votre professeur est complètement incompétent), tout en vous donnant quelques conseils utiles. Je suppose que je suis juste un autre smartass au coeur ... mais un peu utile.

Sooo sans plus tarder ...

Le joueur classe: (celui qui est/était MIA)

package forums.kartikPatel.tennis; 

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

Ceci est un objet de transfert de données immuables. "Immutable" est un terme fantaisiste pour "lecture seule". Cela signifie qu'une fois que l'objet a été créé (une fois que le constructeur a terminé), il ne peut pas être changé. Un "objet de transfert de données" est exactement ce que son nom implique: un objet qui existe UNIQUEMENT pour transférer les données qui représentent quelque chose autour d'autres classes qui "font" des choses avec/à ces données. Il n'a pas (et ne devrait pas) avoir de «smarts» ... les objets de transfert devraient être aussi simples (aussi stupides) que possible.

Voilà ma version de l'équipe Classe:

package forums.kartikPatel.tennis; 

import java.util.ArrayList; 
import java.util.Iterator; 
import java.util.List; 

public class Team implements Iterable<Player> { 

    private final String country; 
    private final List<Player> players; 

    public Team(String country) { 
     this.country = country; 
     this.players = new ArrayList<>(); 
    } 

    public String getCountry() { 
     return country; 
    } 

    public void addPlayer(Player player) { 
     players.add(player); 
    } 

    public Player getPlayer(int index) { 
     return players.get(index); 
    } 

    @Override 
    public Iterator<Player> iterator() { 
     return players.iterator(); 
    } 
} 

La classe d'équipe est un autre objet de transfert de données. Il existe UNIQUEMENT pour garder toutes les informations que nous voulons stocker sur une équipe de tennis en un seul endroit. Cette version fonctionne avec des équipes de n'importe quel nombre de joueurs, ce qui est bien dans la mesure où nous manipulons des équipes de trois joueurs sans changer le logiciel, mais dans cette version, il acceptera aussi des équipes sans joueurs ... et je n'ai pas encore vu ça dans le monde réel (mais bon, si les Kiwis jouent l'équipe des non-corps au moins, ils ont une chance égale, ce qui est un bon changement pour eux), donc notre logiciel ne devrait probablement pas permettre à l'utilisateur de faites cela, alors comme un défi essayez de réparer les choses (non, le logiciel, pas les Kiwis) de sorte qu'au moins un joueur soit requis lors du remplissage de chaque équipe ... ou imprime une "équipe vide!"message d'erreur lorsque nous imprimons les files d'attente

J'ai fait mettre en œuvre l'équipe Iterable car il est logique de voir une équipe comme" un groupe de joueurs, d'un pays "et Iterable nous permet de faire juste que dans la application classe, ce qui est à venir jusqu'à

la application classe.

package forums.kartikPatel.tennis; 

import java.io.PrintStream; 
import java.util.Scanner; 

public class Application 
{ 
    private static final Scanner keyboard = new Scanner(System.in); 
    private static final PrintStream screen = System.out; 

    public void run() { 
     // create two new teams: New Zealand (BOO!) and Australia (YEAH!) 
     Team[] teams = {new Team("NZ"), new Team("AUS")}; 
     // populate both teams with players 
     populate(teams); 
     // display both teams, and all there players. 
     display(teams); 
    } 

    // ------------------------------------------------------------------------ 
    // input 

    // populate both teams with players 
    private void populate(Team[] teams) { 
     for (Team team : teams) { 
      screen.println("Please enter the players for: " + team.getCountry()); 
      for (String name=readPlayersName(); name.length()>0; name=readPlayersName()) 
       team.addPlayer(new Player(name)); 
      screen.println(); 
     } 
    } 
    private String readPlayersName() { 
     return readString("Players Name: "); 
    } 
    private String readString(String prompt) { 
     screen.print(prompt); 
     return keyboard.nextLine(); 
    } 

    // ------------------------------------------------------------------------ 
    // output 

    // display both teams, and all there players. 
    private void display(Team[] teams) { 
     screen.println("The line-ups are:"); 
     for (Team team : teams) { 
      System.out.print(team.getCountry() + ": "); 
      for (Player player : team) 
       screen.print(player.getName() + ", "); 
      screen.println(); 
     } 
    } 
} 

Comme vous pouvez le voir, ceci est une console "traditionnelle" application Lorsque vous. course le tennis.Application il utilise un écran et un clavier pour créer, peuplent, et affichage deux équipes de joueurs. Il contient tout le code qui "fait" des choses dans cette application plutôt simple. Cependant, si/quand les deux équipes se déplacent pour jouer à un match de tennis, je pense que nous voudrions mettre en place une classe séparée (probablement plusieurs) pour jouer au jeu lui-même ... Enfer même, le score pourrait impliquer un Scorer, un DueceHelper, et une grande boîte de pommes de pin (ou peut-être pas).

Ce que la classe d'application ne fait PAS est "remember stuff" ... et pas directement. Il crée et utilise des "objets de transfert" qui "se souviennent de choses".

Il est également intéressant de noter que vous verrez les mêmes trois étapes de base dans tous les types d'applications:

1. Entrée,

2. traitement

   et

3. sortie

   .

Donc, faire ces étapes de base manifeste (par exemple explicite) dans votre code est une bonne idée, surtout pour un débutant, car il vous aide à se concentrer sur le problème que vous devez résoudre ici et comment .. et ne vous laissez pas embrouiller avec les problèmes que vous ne devriez pas essayer de résoudre dans cette méthode/classe/module/sous-système/application ... comme essayer de trouver un grand couteau à pain pour ouvrir la boîte pour faire battre l'ananas le ref au-dessus de la tête avec pendant l'échange gentil d'opinions sur une ligne-appel douteuse mettant fin à un Amour tendu-tout dans le décideur du troisième ensemble ... Évidemment, vous auriez dû préparer vos munitions plus tôt, ou jeter tout le frickin boxe sur lui et espère que son oeil-vue s'améliore avant la fin du match.

Il s'agit de concevoir chaque classe pour remplir un ensemble bien défini de responsabilités. Chaque classe doit contenir des méthodes avec des noms simples et compréhensibles, et en effet chaque méthode implémente une tâche simple et compréhensible. C'est l'essence d'une bonne conception de programme. Garder les choses aussi simples que possible permet de réduire les bugs (erreurs), tout en minimisant les malentendus. Cela aide également à rendre votre logiciel flexible et réutilisable, ce qui signifie qu'il est plus facile à maintenir ... pour s'adapter à des besoins futurs imprévisibles ... ce qui contribue à réduire le coût de possession de logiciels à long terme, ce qui signifie que vous pouvez facturer moins que vos concurrents à faire moins de travail qui fait plus de bien ... et c'est tout bon.

Et enfin mon principal classe:

package forums; 

import forums.kartikPatel.tennis.Application; 

public class Main { 

    public static void main(String[] args) { 
     new Application().run(); 
    } 
} 

La classe principale a une responsabilité: l'exécutionapplication.

Cela produit quelque chose comme la sortie suivante (en fonction de ce que vous entrez, obviousy):

Please enter the players for: NZ 
    Players Name: Bob The Builder 
    Players Name: Kania Fixit 
    Players Name: Yazzie Can 
    Players Name: 

    Please enter the players for: AUS 
    Players Name: Mark Horran 
    Players Name: Blocka Roach 
    Players Name: The Reverand Fred Effing Nile 
    Players Name: 

    The line-ups are: 
    NZ: Bob The Builder, Kania Fixit, Yazzie Can, 
    AUS: Mark Horran, Blocka Roach, The Reverand Fred Effing Nile, 

Comme autre défi, essayez d'obtenir-débarrasser de cette virgule de fin d'alliage après le nom de famille dans chaque équipe. Astuce: Pensez "la virgule précède chaque élément suivant" au lieu de la traditionnelle (plus évidente) penser que la virgule suit chaque élément sauf le dernier ... l'astuce étant bien sûr qu'il est difficile de savoir quand vous avez affaire à la élément final, mais vous pouvez facilement déterminer si/quand vous traitez le premier élément (comme apposé à un autre) d'une liste.

J'espère que cela aide un peu. Vous allez bien pour un débutant. Continuez à essayer et vous comprendrez bientôt plus que moi ... ce n'est pas dur. J'ai été déjoué par un poisson une fois ... longue histoire ;-)

Cheers. Keith