Bonjour j'ai un petit problème  dans un code java très simple

j'ai une classe Article pour représenter les articles vendus dans un supermarché;

et je veux lors de la création d'un nouveau article vérifier si il y a un autre article avec la même référence

car c'est elle qui caractérise l'article de manière unique

voila le code j’espère qu'il est visible 

public class Article {

	private long reference;
	private String intitule;
	private float prixHT;
	private int quantiteEnStock;
	
	public Article(long reference,String intitule,float prixHT,int quantiteEnStock){
		
		setReference(reference);
		setIntitule(intitule);
		setPrixHT(prixHT);
		setQuantiteEnStock(quantiteEnStock);
	}

	public String getIntitule() {
		return intitule;
	}

	public void setIntitule(String intitule) {
		this.intitule = intitule;
	}

	public long getReference() {
		return reference;
	}

	public void setReference(long reference) {
		this.reference = reference;
	}

	public float getPrixHT() {
		return prixHT;
	}

	public void setPrixHT(float prixHT) {
		this.prixHT = prixHT;
	}

	public int getQuantiteEnStock() {
		return quantiteEnStock;
	}

	public void setQuantiteEnStock(int quantiteEnStock) {
		this.quantiteEnStock = quantiteEnStock;
	}
	
	public void approvisionner(int nombreUnites){
		setQuantiteEnStock(nombreUnites+getQuantiteEnStock());
	}
	public boolean vendre(int nombreUnites)
	{
		if(nombreUnites<getQuantiteEnStock())
		{
		setQuantiteEnStock(getQuantiteEnStock()-nombreUnites);
		return true;
		}	
		else 
		return false;
	}
	public float prixHT(){
		return getPrixHT();
	}
	public float prixTTC(){
		return (1+ (float)0.196)*getPrixHT();
		//return 1;
	}
	public String toString ()
	{
		return(" l'article num:"+getReference()+" "+getIntitule()+" "+getPrixHT()+" et le quantite en stock est :"+getQuantiteEnStock());
		//return("aaaa");
	}
	public boolean equals(Article unArticle)
	{
		if(unArticle.getReference()==getReference())
			{System.out.println("true");
			return true;} 
			else
				System.out.println("false");
				return false;
	}
public static void main(String[] args) {
		
Article[] articles;
articles=new Article[10];
articles [1]=new Article(1,"intitu",10,100);
articles [2]=new Article(2,"intitu2",20,200);
articles [3]=new Article(3,"intitu3",30,300);
articles [4]=new Article(4,"intitu4",40,400);

//articles[1].equals(articles[2]);
articles[1].approvisionner(10);

articles[1].vendre(100);
//System.out.println(articles[1]);
//articles[1].prixTTC();
System.out.println (articles[2].prixTTC());
for(int i=1;i<4;i++){
	System.out.println (articles[i]);	
}
}
}

-
Edité par amarillo 3 mars 2015 à 14:33:10

alors pour bien faire, un article ne devrait pas avoir la vue sur d'autres article, ce serait contraire aux règle de la programmation objet. C'est au moment de créer un nouvelle article (dans le main donc, même si tu pourrais faire un articleManager par example) que tu devrais appeler une fonction créerArticle qui vérifierais le contenu de ton tableau et ne créerais l'article que si sa référence n'est pas utilisée

merci beaucoup pour votre réponse,

d’après ce que j'ai compris la vérification ne peut pas se faire au niveau du constructeur c'est ça?!

mais comment vérifier la référence de l'article  avec la fonction creerArticle avant que  les information soient envoyer par le constructeur?

elle pourrait, mais il faudrait contenir la liste des article dans la classe article pour pouvoir la vérifier ou la passer dans le constructeur. Dans les deux cas, ce n'est plus un simple modèle d'objet mais ça devient un objet gérant des données. 

Du coup, au lieu d'avoir

articles [1]=newArticle(1,"intitu",10,100); 

on aurait 

createArticle(articles, 1,"intitu",10,100) 

qui vérifierais dans articles que la référence passée n'est pas déjà présente, et si non ajoute l'objet à articles. Je te laisse déduire ce qu'il faut mettre dedans.

-
Edité par Maxime00 3 mars 2015 à 16:38:54

re-salut ;

malheureusement j'ai pu le faire,

est ce que ça doit être une méthode membre de la classe,si oui comment je dois l'appeler et qu'est ce qu'elle va retourner(l'objet cree?)?

et merci d'avance!

Je crois que ce qu'il voulais dire c'est que tu doit créer une méthode static dans ton main.java.

Pour le type de return tu peut faire Article createArticle(Article[] articles, int posInTab, int id,/* les params à passer au constructeurs*/)

Tu retourne null si il y a déjà un article avec le même id, sinon tu créer un nouvel Article que tu ajoute à la case [posInTab] de articles.

Bonsoir.

Soit la classe Article gère le stock des articles, soit tu le fais dans le main() (qui pour le coup se trouve dans la classe Article) comme tu as commencé à le faire.

Si tu fais un tableau dans le main, alors tu créés une fonction nouvelArticle(long reference) qui parcours le tableau pour vérifier si la référence si trouve déjà. Si ce n'est pas le cas il appelle le constructeur, sinon il prévient l'utilisateur.

Si tu stock dans la classe, alors le tableau est static: il est partagé par toutes les instances de la classe. Tu créés une fonction statique articleManager() qui vérifie avant d'appeler le constructeur. Si la référence s'y trouves déjà tu renvois une référence sur un objet Article de valeur null. Dans ce cas tu peux mettre le constructeur en private pour obliger à passer par la fonction qui gère la création et l'ajour aux stocks des nouveaux Articles.

Le plus simple reste de créer un champs private static long derniereRef = 0 et de faire dans le constructeur:

public Article(String intitule,float prixHT,int quantiteEnStock) {
    	derniereRef++; 
       	reference = derniereRef;

(pas besoin d'utiliser les accesseurs getXXX à l'intérieur de la classe)

-
Edité par Huntil 4 mars 2015 à 5:42:08

Re-salut

Merci beaucoup pour votre aide, la methode avec la reference auto-incrementable marche tres bien.

j'ai une autre question SVP est ce que vous pouvez m'aider a comprendre ce bout de code qu'un ami m'a proposé

le voila:

private static Set<Long> allReferences = new TreeSet<Long>();

public void setReference(long reference) throws IllegalArgumentException {
    if (allReferences.contains(reference))
        throw new IllegalArgumentException("reference already used: "+reference);

    allReferences.remove(this.reference);
    allReferences.add(reference);

    this.reference = reference;
}

c'est grosso modo ce que je t'avais proposé, un tableau qui contient toutes les références déjà utilisée, et une fonction qui permet de vérifier qu'une nouvelle référence n'est pas déjà présente.

Ici, Le throw new exception permet de faire remonter une erreur dans le cas ou tu essaye d'utiliser une référence qui existe déjà. Dans le cas ou la référence n'est pas présente, on remplace dans la liste des références l'ancienne référence utilisée par l'article, puis on modifie la référence de l'article.

Je n'en ai pas parlé mais une dernière solution est effectivement d'utiliser une structure de données qui n'autorise pas les doublons, comme un ensemble. La documentation de Set et TreeSet se trouve sur le site d'oracle.