Can I call on different instances of a class that have the same name?

For a project I am working on in class, I am required to create an ArrayList containing an undefined number of adherents (instances of a class) which all possess different names, Id's, etc. I then have to call on one of them to, for example, change it's Id(using a method like adherent.setId(newId)).

However, with the way my code is setup, all new instances are called the same, and because the number of adherents is undefined, I can't simply use something like

Adherent adherent1 = new Adherent(lastName, firstName, currentYear, currentId);
Adherent adherent2 = new Adherent(lastName, firstName, currentYear, currentId);
Adherent adherent3 = new Adherent(lastName, firstName, currentYear, currentId);

etc... for each of them.

This is the method I am currently using

public static List<Adherent> createAdherent(int currentId, int currentYear, List<Adherent> adherentList) {
        Scanner sc = new Scanner(System.in);

        System.out.println("Please enter the last name of the new adherent");
        String lastName = sc.next();
        System.out.println("Please enter the first name of the new adherent");
        String firstName = sc.next();

        Adherent adherent = new Adherent(lastName, firstName, currentYear, currentId);

        adherentList.add(adherent);

        adherent.setName(lastName);
        adherent.setFirstName(firstName);
        adherent.setYearAd(currentYear);
        adherent.setId(currentId);
        System.out.println(adherent.toString());

        return adherentList;
    }

I am wondering if there is a way to call on them (use .set or .get method) using something other than their names (maybe a variable) or if there is a way to name them all differently in my createAdherent() method. I have been searching for a couple days and can't seem to find an answer.

Your method is an interesting one. I would consider some refactoring.

First, you're taking in a List, adding an item to it, then returning that List. The return is pointless as you're already adding to the list.

Given the signature of createAdherent(int currentId, int currentYear, List<Adherent> adherentList), you're passing in a List. Instead, consider making your method

public Adherent createAdherent(int currentId, int currentYear) (static if you must)

Then you would call it like this:

adherents.add(createAdherent(1, 2000))

where adherents is the List of Adherent that you were passing in. No need to take a List or return a List, just return the object that you want to add to the List.

From what I understand you want to call an item by name and change its id, but there may be more than 1 item with the same name.

Note: I believe that if you are passing 'lastName' and 'firstName' in the constructor itself, it should update the variable values, with no need to call .setName(lastName) and .setFirstName(firstName)

Returning to your problem, I believe that if you are getting the obj by name to change the id, knowing that there may be more than one with this name, I think this should not happen. What I believe can be done:

• Op 1: Prevent the creation of an object with the same name, putting its creation in a loop, validating if there isn't one with that name and, if not, adding it to the array. You can even put a message that there is already one with this name. Or returning an error that will be handled by the caller using a try{ createAdherent(); }catch(Exception e){...}

• Op 2: Do not search by name but by id (I believe this is the best option to search for an object, as an id would do just that), but as it is an array you would end up going through it all, which is bad, you could use a Map<Integer, Adherent> to get it by id.

• Op 3: If the problem is that you don't know which 'Adherent' was created because the function return is an array(what i don't recomend cause the function name), then you could, inside the 'createAdherent' function, return only the new 'Adherent' (which is kinda like that's his name), and leave it in case it is necessary to get the other values, these are taken by another function, such as:

    public static List<Adherent> getAdherents(){
       //If you don't want to be able to delete the object from the array externally
       return Collections.unmodifiableList(adherentList);

       //Or simply
       return adherentList;
    }

Or use all then.

Hope this helps

Your function createAdherent must be better named createAdherentInList as you give the list to update in the parameters. And no need to return the list, as already said, it's already done.

I believe your problem is a more classic one about owning a unique ID for each instance.

• Either you decide to generate automatically the ID and never allows an external call to change this ID that will stay unique.
• Either this ID is free to be changed and you have no way to distinguish an adherent from another except by its position when it was added . You can retrieve it by it's order of insert : Adherent myList.get(position).

In any case, you need some another functions to retrieve an adherent like:

Adherent findAdherentById(someUniqueId)
list <Adherent> findAdherentByName(someName) // here returns a list as it can have homonyms and you will have to choose one before to be able to change something.

HTH

The instances are not called adherent1, adherent2, etc. Those are only the names of variables, which are only loosely associated with instances of objects.

You can get to your instances from the list as adherentList.get(0), etc.

You can process them all by constructs such as for (adherent : adherentList) ....

There might be better ways to organize the data, but that requires more infomation about what you need to do with it.