Un peu de java

Hello,

Si tu veux de l'aide, il faut que tu reprennes tes cours, que tu commences ton projet et si tu rencontres des soucis, Kij82 se fera un plaisir de te filer un coup de main. :)

Désolé pour le ton, toutes mes excuses wiki.

Ou bloque tu exactement dans la compréhension ou la mise en place du tp3 ?

Interprétation de l’énoncé pour la préparation au codage :



Je cite : « Un object porte monnaie électronique »  ce qui veut donc dire que tu aura une classe « PorteMonnaieElectronique ».

Je cite : « Etat du porte monnaie »  a comprendre « propriété de la classe »

« La carte possède un code secret de 4 numéro »  propriété code_secret qui sera une chaine de caractère avec 4 numéros concaténés. « Ne doit pas être lisible ni modifiable une fois généré »  ce qui signifie que tes accesseurs à cette propriété sont strictement privé !
« La carte tiens à jour un compteur… »  propriété compteur qui sera un entier, initialisé à 3 dans le constructeur de la classe.
« Le montant est enregistré sous forme d’un réel »  propriété « montant » qui sera donc de type Float.
« Séquence de transaction … »  cela signifie que tu aura une méthode de type publique (appelable depuis l’extérieur de la classe donc) nommée « transaction » qui effectuera les opérations suivante tour à tour :
- Message de bienvenu à l’utilisateur
- Proposition de rentrer le code
- Lecture du code rentré
- Validation du code (et cela trois fois maximum si code faux  test en boucle donc)
- Proposition de débiter ou créditer le compte
- Lecture du choix et du montant
- Opération sur le compte
- Message de fin à l’utilisateur


« On a besoin de savoir à un moment donné si une transaction est en cours »  propriété « transaction_en_cours » de type boolean permettant de savoir si une transaction est en cours ou non. Cette propriété est mise à false dans le constructeur, puis à true au départ de la méthode de transaction (et remise à false en cas de sortie de cette méthode, par erreur ou en fin de méthode)

Voilà pour ce qui est de la structure de ta classe.

Maintenant la partie 2.2 de l’énoncé, le comportement du porte monnaie. Cette partie décrit le fonctionnement du constructeur de la classe – à savoir qu’il doit initialisé le code secret et l’afficher à l’utilisateur lorsqu’il est initialisé (en fin de constructeur donc). De même pour les principaux passages de la méthode « transaction ».

Voilà donc une explication de ton énoncé, en espérant que tu ai compris ce que j’ai voulu dire ^^
Je mettrais cet apres midi le squellette et il te restera à le remplir. De cette facon tu verra comment interprété un énoncé correctement et construire ce qu’il est demandé. Apres tu pourra t’exercer sur le TP4 tout seul pour mettre à profit ce que tu aura appris (si toutefois tu apprends quelque chose bien sur).

Voici la classe PorteMonnaieElectronique :

class PorteMonnaieElectronique {

	// #########  CONSTANTES  ############
	// --- Nombre d'essai maximum pour entre le code
	private static final int NB_ESSAIS = 3;
	// --- Nombre de numéro du code secret
	private static final int NB_NUM = 4;
	
	// #########  PROPRIETES  ############
	// --- Code secret du porte monnaie
	private String code_secret = null;
	// --- Témoin de transaction en cours
	private boolean transaction_en_cours = false;
	// --- Montant sur la carte bancaire
	private float montant = 0;
	
	
	// #########  CONSTRUCTEUR #############
	PorteMonnaieElectronique ( ){
		
		// ### Génération du code secret
		// --- Initialisation du code secret :
		setCodeSecret("");
		// --- Initialisation du témoin de transaction
		setTransactionEnCours(false);
		
		// --- Initialisation de l'objet Random
		Random rand = new Random();
		
		// --- Génération de 4 chiffre que l'on concataine au code secret au fur et à mesure
		for (int i = 0; i < NB_NUM; i++ )
			// Ici l'opérateur % = Modulo et permet de prendre le reste de la division par 10 du chiffre généré.
			getCodeSecret().concat( Math.abs(rand.nextInt()) % 10 );
			
		// --- Révélation du code secret à l'utilisateur
		reveler_code();
		
	}
	
	// ######### ACCESSEURS ##########
	// --- Accesseur privé car ne doit pas être accessible depuis l'extérieur de la classe
	private String getCodeSecret ( ){
		return this.code_secret;
	}
	// --- Accesseur privé car ne doit pas être accessible depuis l'extérieur de la classe
	private setCodeSecret ( String code ){
		this.code_secret = code;
	}
	public boolean isTransactionEnCours ( ){
		return this.transaction_en_cours;
	}
	// --- Accesseur privé car ne doit pas être accessible depuis l'extérieur de la classe
	private setTransactionEnCours ( boolean value ){
		this.transaction_en_cours = value;
	}
	public void setMontant ( float m ){
		this.montant = m;
	}
	public float getMontant ( ){
		return this.montant;
	}
	
	// ######## METHODES DE LA CLASSE ########
	public void transaction ( ){
		
		// --- Selon le retour de la vérification du code :
		switch ( commencerTransaction ){
			case -2:	// --- Transaction déjà en cours sur cette carte
				System.out.println("Une transaction est déjà en cours sur cette carte, veuillez essayer plus tard.");
				break;
			case -1:	// --- Le nombre de tentative est dépassé, on affiche un message à l'utilisateur
				System.out.println("Nombre d'essai dépassé ! Votre carte va être avalée...");
				break;
			case 0:	// --- Anulation de l'utilisateur
				System.out.println("Transaction annulée, votre carte devrait vous être restituée...";
				break;
			case 1:	// --- L'authentification est réussie, on passe à la suite des opérations
				// --- Blocage de la carte --> transaction en cours
				setTransactionEnCours(true);
				
				// ICI FAIRE LA DEMANDE A L UTILISATEUR DE CE QU IL VEUT FAIRE (débiter ou créditer)
				// PUIS LUI DEMANDE D ENTRE LA SOMME ET APPELER LA METHODE ADEQUAT 'crediter' ou 'debiter'
				
				break;
			default:
				break;
		}
		
		// --- Fin de la transaction
		terminerTransaction();
		
	}
	
	private void commencerTransaction ( ){
		// --- Si la carte est bloquée car déjà en transaction
		if ( isTransactionEnCours() )
			return -2
		// --- Sinon, tentative de vérification du code
		else
			return verifierCode();
	}
	
	private void terminerTransaction ( ){
		// --- Message utilisateur de fin de transaction
		System.out.println("Au revoir...");
		// --- Déblocage de la carte si besoin
		if ( isTransactionEnCours() )
			setTransactionEnCours(false);
	}
	
	private void debiter ( float somme ){
		// --- Si la somme demandée dépasse la somme actuelle, refus.
		if ( somme > getMontant() ){
			System.out.println("Vous ne pouvez pas dépasser votre montant actuel de '"+getMontant()+"'");
			return;
		}
		// --- Débit de la somme demandée
		setMontant ( getMontant() - somme );
	}
	
	private void crediter ( float somme ){
		// --- Crédit de la carte
		setMontant(getMontant()+somme);
	}
	
	/**
	* Méthode qui permet de saisir un code confidentiel et 
	* de le comparer à l'existant. Retourne vrai si l'authentification est réussie
	* sinon retourne faux
	*/
	private int verifierCode ( ){
		int compteur = 0;
		do{
			// --- En cas d'erreur, affichage d'un message approprié	
		  if ( compteur > 0 )
		  	System.out.println("Code érroné !");
		  	
			// --- Lecture du code :
			String code = Lire.jint("Veuillez entrer les 4 chiffres de votre code confidentiel (Q pour annuler): ");
		// --- Le test est effectué autant de fois que paramètré et ce si le code rentré différe du code généré.
		// --- De même, on test le fais que l'utilisateur puisse choisir d'annulé la transaction en tapant la lettre 'Q'
		}while( compteur < NB_ESSAIS && code.equalIgnoreCase("Q") && getCodeSecret().equalIgnoreCase(code) != 0 );
		
		// --- On retourne faux si l'on a dépassé le nombre d'essai autorisé
		if ( compteur == NB_ESSAIS )
			return -1; // --- Nombre d'essais dépassés
		// --- Vrai si l'authentification est réussie
		else if ( code.equalIgnoreCase("Q") )
			return 0; // --- Annulation de la transaction
		else
			return 1;	// --- Authentification réussie
		
	}
	
	private void reveler_code ( ){
		System.out.println("Votre code confidentiel est le suivant : "+getCodeSecret());
	}
	
}

Il ne te reste plus qu'à faire ce qui est mis en commentaire dans la méthode 'transaction', c'est à dire à faire un menu texte proposant soit une opération de débit, soit une opération de crédit à l'utilisateur, de lui demander le montant et d'effectuer l'opération.
Tu dois faire aussi une classe extérieur 'Utilise' ayant un Main. Dans ce main, tu créé une instance de portefeuille :

PorteMonnaieElectronique p = new PorteMonnaieElectronique();
p.transaction();

et tu lance la transaction.

Voilà, il faut aussi que tu inclut les différentes classes utilisée en important les bons packages.

Si tu as des questions, n'hésite pas.