Comment ajouter un objet dans un autre Objet

J'ai deux classes. Une(Personne) pour les getters et les setters, et l'autre(les Gens) pour calculer les données. Qu'est-ce que ma situation est, je reçois les données de la DB à l'aide de ResultSet, puis créé un Objet personne pour stocker les données de ligne. Puis j'ai créé les gens de l'Objet pour stocker toutes les personnes.

Chaque Objet créé en tant qu'ENSEMBLE.

while(rs.next())
{
    Set<People> people = new HashSet<people>();
    Person person = new Person();
    String name = rs.getString(2);
    person.setName(name);
    int id = rs.getInt(1);
    person.setId(id);
    String dept = rs.getString(4);
    person.setDept(dept);
    int age = rs.getInt(3);
    person.setAge(age);
    people.add(person);
}
return people;

Maintenant, le problème, c'est la dernière ligne dans la Boucle While people.add(person);

Il dit

La méthode add(les Gens) dans le type de Jeu n'est pas applicable pour les arguments (Personne)

Comment puis-je résoudre ce problème?

Grâce.

OriginalL'auteur | 2010-08-23

Mon understandig à partir de votre conception est que vous avez un Gens a beaucoup de Personne relation, de sorte que le People classe contient une collection de Person objets. Alors je m'attend à quelque chose comme ceci:

public class Person {
  private String name;
  private Date dateOfBirth;
  //.. more attributes

  //getters and setters

  //overrides of equals, hashcode and toString
}

public class People implements Set<Person> {
  private Set<Person> persons = new HashSet<Person>();

  public boolean add(Person person) {
    return persons.add(person);
  }

  //more methods for remove, contains, ...
}

Dans votre base de données connexes code que vous n'avez pas besoin de créer un autre, parce que People a déjà celui dont vous avez besoin:

People people = new People();  //or get it, if it's already created
while(rs.next())
{
    Person person = new Person();
    String name = rs.getString(2);
    person.setName(name);
    int id = rs.getInt(1);
    person.setId(id);
    String dept = rs.getString(4);
    person.setDept(dept);
    int age = rs.getInt(3);
    person.setAge(age);
    people.add(person);
}
return people;

OriginalL'auteur Andreas_D

Je ne comprends pas pourquoi vous voulez les 2 classes à la première place. Vous cand ont Personne à mettre en œuvre le calcul de la partie. Mais, néanmoins, ce que vous pourriez faire:

class People implements Set<Person> {

private HashSet<Person> hashset = new HashSet<Person>();

//... your computational code goes here
//delegate all Set methods to hashset
}

et puis:

People people = new People();
while(rs.next())
{
    Person person = new Person();
    String name = rs.getString(2);
    person.setName(name);
    int id = rs.getInt(1);
    person.setId(id);
    String dept = rs.getString(4);
    person.setDept(dept);
    int age = rs.getInt(3);
    person.setAge(age);
    people.add(person);
}
return people;

D'accord. Si les Gens délégués HashMap au lieu d'hérite serait mieux:)
Correct. Vous pourriez avoir pensé, bien 🙂

OriginalL'auteur drstupid

1

En fonction de ce que vous essayez de le faire je le sens, vous devez convertir votre Personne pour les Gens de la classe avant de l'ajouter à l'ensemble. Votre les Gens de la classe dispose d'un constructeur qui prend une Personne comme argument et copie les champs obligatoires de la Personne à la les Gens. Ici votre code à ajouter à l'apparence comme people.add(new People(person));

Lorsque vous déclarez Set<People> people = new HashSet<People>(); ce que cela signifie, c'est que ce jeu est censé contenir des objets de type " les Gens c'est à dire des cas de Personnes ou d'instances de sous-classes de Personnes. Si les Gens n'est qu'une interface, l'ensemble peut contenir n'importe quel objet qui implémente l'interface.

OriginalL'auteur Gopi
1

Je comprends Person est une structure de données (bean-like, avec des getters et setters), et People doit contenir tous les Person objets de la base de données et effectuer des calculs sur eux.

Si cela est vrai, tout d'abord, vous ne pouvez pas déclarer de personnes à l'intérieur de la boucle (car un nouveau People objet sera créé pour chaque Person, et vous ne voulez pas que, d'après ce que je comprends).

Deuxième, People doit être en mesure de contenir les objets de la Personne. Donc, il devrait au moins être composé d'un Set de Person objets. Vous pouvez ajouter plus de fonctionnalités, comme vous s'il vous plaît. Donc, essayez quelque chose comme ceci:
```
public class People {

    Set<Person> persons = new HashSet<Person>();

    Set<Person> getPersons() {
        return persons;
    }

    int computeSomethingAboutPeople() { 
        //return as you please
    }

}
```
Et de l'utiliser comme ceci, comme l'affiche précédente a suggéré:
```
People people = new People();
while(rs.next())
{
    Person person = new Person();
    String name = rs.getString(2);
    person.setName(name);
    int id = rs.getInt(1);
    person.setId(id);
    String dept = rs.getString(4);
    person.setDept(dept);
    int age = rs.getInt(3);
    person.setAge(age);
    people.getPersons().add(person);
}
int answer = people.computeSomethingAboutPeople();
```
Ont People la mise en œuvre de la Set interface. Ensuite, vous pouvez l'utiliser comme un Jeu et ne pas avoir à forcer l'utilisateur à faire quelque chose comme people.getPersons().add(person);. Et si fournir une lecture de l'ensemble, de ne pas retourner à l'interne, de retour d'un Collections.unmodifiableSet(persons), de sorte que personne ne peut changer le fonctionnement interne.
Merci pour votre réponse. Il m'a aidé. Mais j'ai une autre question. Dois-je déclarer un jeu pour la Classe Personne. Comme, Set<Personne> personnes = new HashSet<Personne>(); .

OriginalL'auteur double-m
0

Je ne pense pas que Set<People> people = new HashSet<people>(); doit être écrit dans la boucle.

Le gros problème est à la ligne de la "les gens.ajouter(personne);". La déclaration est juste une faute de frappe
Ya, je viens de là... ce n'est pas réellement déclarée.

OriginalL'auteur 卢声远 Shengyuan Lu

class Cartesian
{
   double x,y,z;
   public
   Cartesian()
   {
      x=y=z=0;
   }
   Cartesian (int i,int j,int k)
   {
        x=i;
        y=j;
        z=k;
   }

   Cartesian add_coordinates(Cartesian c)
   {
        c.x=x+c.x;
        c.y=y+c.y;
        c.z=z+c.z;      
        return c;                 
   }

   void display()
   {
        System.out.println("Addition of coordinates is : "+x+"i "+y+"j "+z+"k ");
   }

}

class Coordinate
{
  public static void main(String[] args)
  {
       Cartesian obj1 = new Cartesian(5,5,-10);
       Cartesian obj2 = new Cartesian(5,5,-10);
       Cartesian obj3 = new Cartesian();
       obj3=obj1.add_coordinates(obj2);
       obj3.display();
  }
}

Veuillez envisager d'ajouter quelques explications.

OriginalL'auteur Shivam Thacker

Vous devez vous connecter pour publier un commentaire.