Java créer un ID unique pour chaque objet instancié à l'aide de méthodes d'instance au lieu de la classe/méthodes statiques

Assez nouveau pour ce j'espère donc avoir la terminologie utilisée dans le titre de la droite.

Je suis à essayer de comprendre comment créer un méthode d'instance que va faire ce qui suit:

--Un numéro d'identification est retourné.

--Que chaque objet est créé à partir du constructeur de la classe(instancié?), un entier unique numéro d'identification est attribué. Le premier numéro de l'ID est 1, et que de nouveaux objets sont instanciés, les numéros seront attribués.

Je suis en mesure de trouver des exemples de la classe/méthodes statiques qui ne le ci-dessus, cependant je n'arrive pas à comprendre comment faire cela avec une méthode d'instance. Ma tentative est ci-dessous:

class Coordinates
{
    private int iD = 0;
    private float xCoordinate;
    private float yCoordinate;

    public Coordinates()
    {
        //Asks for input and assigns it to the two variables below
        Scanner keyboard = new Scanner(System.in);
        System.out.println("Please enter the X Coordinate followed by the return key");
        xCoordinate = keyboard.nextDouble();
        System.out.println("Please enter the Y Coordinate followed by the return key");
        yCoordinate = keyboard.nextDouble();

        iD++;
    }

    public getiD()
    {
        return iD;
    }

}

Ma méthode main est comme suit:

public class Machine
{
    public static void main(String[] args)
    {
        Coordinates c1 = new Coordiantes();
        Coordinates c2 = new Coordiantes();
        Coordinates c3 = new Coordiantes();

        System.out.println("ID: " + c1.getID());
        System.out.println("ID: " + c2.getID());
        System.out.println("ID: " + c3.getID());


    }
}

Veuillez noter que je n'ai pas inclus la totalité de mon code pour des raisons de simplicité et de facilité à suivre. J'espère que j'ai ajouté assez.

Aussi, je ne veux pas utiliser java.util.UUID.

Vous avez besoin d'un static id générateur et une instance id champ de l'instance en cours.

OriginalL'auteur SeesSound | 2016-02-17

3

Le problème maintenant est que votre " id " est une variable d'instance en ce sens qu'elle appartiennent les objets que vous créez.
Penser que chaque fois que vous créez un objet une nouvelle copie de votre variable d'instance est faite.
Donc, chaque fois que vous créez un objet, l'id est tout d'abord définie à 0, alors le poste augmenté une fois (donc tous les objets ont un id=0).

Si vous souhaitez créer une variable qui, par exemple, compte automatiquement tous les objets que vous avez créé dans une classe ou a l'id, vous avez besoin de faire une variable de classe.
Ces variables appartiennent à tous les objets que vous créez à partir d'une classe et le mot-clé utilisé pour cela est "statique".

Note: j'ai utilisé une variable statique, MAIS pas une méthode statique. Si vous ne souhaitez pas utiliser statique à tous, c'est une autre question
```
class Coordinates
{
private static int count = 0;
private int id=0;
private float xCoordinate;
private float yCoordinate;

public Coordinates()
{
    //Asks for input and assigns it to the two variables below
    Scanner keyboard = new Scanner(System.in);
    System.out.println("Please enter the X Coordinate followed by the return key");
    xCoordinate = keyboard.nextDouble();
    System.out.println("Please enter the Y Coordinate followed by the return key");
    yCoordinate = keyboard.nextDouble();

    id=count++;
}

public getiD()
{
    return iD;
}

}
```
Un simple changement de mot-clé feront de votre programme correct. Vous n'avez pas à faire trop compliqué tout ça.

Il est difficile de saisir le concept de classe et les objets statiques et variables d'instance au premier abord. Laissez-moi savoir si vous voulez plus d'explication 🙂

Excellent facile à suivre l'exemple. La seule modification que j'ai apporté a id=++compter, de sorte que, lorsqu'une objection est instancié, la valeur de comptage de change pour 1 ET ENSUITE être affecté à pointID. Cela permettrait de faire en sorte que l'id serait de commencer à partir de 1 au lieu de 0
Je suis content de le savoir!
Comment on pourrait y parvenir sans statique?
Voir ci-dessous la réponse de stackoverflow.com/a/35461985/5930693

OriginalL'auteur CoderBC
3

Le maintien d'un ID de séquence distincte de la responsabilité de tout le reste de ce que votre objet n', et n'appartient pas à une instance de l'Coordonnées de la classe, de sorte qu'il appartient à un autre objet. Faire un objet distinct de maintenir la séquence et de la main de chiffres, quelque chose comme
```
public class MySequence {
    private AtomicLong currentValue = new AtomicLong(0L);
    public long getNextValue() {
        return currentValue.getAndIncrement();
    }
}
```
ensuite utiliser cette séquence pour initialiser vos objets:
```
new CoordinatePair(mySequence.getNextValue(), x, y);
```
Par la façon de garder l'entrée d'utilisateur distinct du modèle rend les choses plus simples, vous pouvez instancier vos Coordonnées classe dans les cas où l'entrée n'est pas donnée par l'utilisateur. Entrée de la Console de ne pas aller dans un constructeur. Vous pourriez avoir une coordonnée de classe comme
```
public CoordinatePoint {
    private long id;
    private float x;
    private float y;
    public CoordinatePoint(long id, float x, float y) {
        this.id = id;
        this.x = x;
        this.y = y;
    }
    public String toString() {
        return "id=" + id + ", (" + x + ", " + y + ")";
    }
}
```
et d'une méthode principale comme
```
public class Example {

    public static void main(String ... args) {
        MySequence seq = new MySequence();
        Scanner keyboard = new Scanner(System.in);
        System.out.println("Please enter the X Coordinate followed by the return key");
        float xCoordinate = keyboard.nextDouble();
        System.out.println("Please enter the Y Coordinate followed by the return key");
        float yCoordinate = keyboard.nextDouble();
        CoordinatePoint c1 = new CoordinatePoint(seq.getNextValue(), xCoordinate, yCoordinate);
        System.out.println(c1.toString());
    }
}
```
C'est un peu dur pour quelqu'un comme moi de suivre. Pourriez-vous développer votre code pour expliquer AtomicLong, et getNextValue. Aussi, d'où vient l'entrée de la console? Dans la méthode main droite devant un objet est instancié?
AtomicLong est ici: docs.oracle.com/javase/8/docs/api/java/util/concurrent/atomic/..., c'est juste encapsule une valeur et permet des mises à jour automatiquement. Et oui, la principale méthode serait un bon endroit pour faire votre entrée de la console.
Vous pouvez utiliser un LongAdder au lieu de AtomicLong si le multi-threading et la haute performance sont importantes. blog.palominolabs.com/2014/02/10/...
il n'y a aucune indication que le multithreading est pertinente ici. J'ai utilisé AtomicLong ici parce que c'est facile et je ne voulais pas overthink un jouet exemple (bien que toujours l'arrêt de nitpickers qui se plaignaient de l'aide ++ ou +=).

OriginalL'auteur Nathan Hughes

Dans le cadre de votre code actuel, la chose la plus simple à faire est comme ci-dessous:

import java.util.concurrent.atomic.AtomicInteger;

public class Coordinates {

    //static id generator shared among all instances of Coordinates 
    private static final AtomicInteger idGenerator = new AtomicInteger(1000);

    private final Integer id;

    public Coordinates() {
        //assign unique id to an instance variable
        id = idGenerator.getAndIncrement();
    }

    public int getId() {
        //return instance variable
        return id;
    }
}

Test

public class Test {

    public static void main(String[] args) {
        for(int i = 0; i < 10; ++ i){
            System.out.println(new CoordinatePoint().getId());
        }
    }
}

Sortie

1000
1001
1002
1003
1004
1005
1006
1007
1008
1009

OriginalL'auteur Alan Hay

0

Vous pouvez soit faire de ce ID statique, ou vous pourriez juste faire une classe Parente, appelé "Coordonner" (ID de nouveau statique) avec "le Point" des enfants, et incrémenter le code dans le constructeur de chaque "Point" de l'objet.

Statique semblerait que le chemin à parcourir.

OriginalL'auteur pegas

Vous devez vous connecter pour publier un commentaire.