Questions débutant

Tu peux tout simplement continuer la concaténation comme tu l'as commencé :

System.out.print("L'étudiant " + leNom + "a obtenu " + noteMaths + "en mathématiques.");

"comment supprimer le soulignage des mots dans les commentaires"
Écris les en anglais :-)
Sinon en passant ta souris au dessus d'un mot souligné tu dois avoir "Disable spell check"

la dernière phrase ne s'affiche pas
Si c'est toujours le même code, tu as deux nextInt, il faut donc taper deux valeurs (ou en supprimer un des deux) avant que la ligne ne s'affiche.

Évites de poster du code ailleurs que sur CCM ce n'est pas pratique, en plus pour deux classes à copier-coller ce n'est pas ça qui va alourdir la page...

Tu as écrit :

System.out.println(+paris1.getNomVille()+"est une ville de "+paris1.getNomPays()+"contenant plus de"+paris1.getNbHabitants()+"habitants.");

Il y a évidemment un problème au tout début, Eclipse te le souligne d'ailleurs en rouge, l'opérateur + est binaire, il requiert d'avoir un opérande à gauche et un opérande à droite, ici tu n'as rien à gauche, forcément ça ne peut pas compiler.

Il faudrait écrire :

System.out.println(paris1.getNomVille()+"est une ville de "+paris1.getNomPays()+"contenant plus de"+paris1.getNbHabitants()+"habitants.");

Cela t'afficheras donc :

Création d'une ville :
nullest une ville de nullcontenant plus de0habitants.

Le null vient de la valeur par défaut de tes attributs privés, car ils ont été mal initialisés dans le constructeur.

private String nomVille; // null par défaut
private String nomPays; // null par défaut
private int nbHabitants; // null par défaut

public Ville(String pNomVille, String pNomPays, int pNbHabitants)
{
    pNomVille = nomVille;
    pNomPays = nomPays;
    pNbHabitants = nbHabitants;
}

Il fallait faire l'inverse :

public Ville(String pNomVille, String pNomPays, int pNbHabitants)
{
    nomVille = pNomVille;
    nomPays = pNomPays;
    nbHabitants = pNbHabitants;
}

Ce qui donne :

Création d'une ville :
Parisest une ville de Francecontenant plus de1000habitants.

Bonsoir,

Qu'est-ce que la InputValue.readString ? Si ça fait une entrée au clavier ça n'a rien à faire dans un constructeur, donc gardes uniquement le deuxième constructeur de StringSentence.

Dans le même genre, extractWords ne devrait pas faire d'affichage, mais renvoyer le résultat avec un return. Les intéractions entre le programme et l'utilisateur c'est uniquement avec la classe de test, tout le reste doit être autonome.

Cependant je ne vois pas l'intérêt de faire une classe pour cela, tu devrais plutôt faire une méthode static qui prendrait en entrée ce que tu passes actuellement à ton constructeur, et en sortie le résultat de extractWords. Conserver les objets sentence et words serait inutile, voire même faux si on considère que tu pourrais faire deux appels successifs à extractWords...

Enfin, pour le coeur du problème (même si l'enrobage est déjà bien bancale), tu ne devrais pas utiliser StringTokenizer, c'est du vieux code Java 1, et comme beaucoup d'autres classes de cette génération il vaut mieux l'éviter complètement. Regarde la documentation c'est assez explicite !

https://docs.oracle.com/javase/7/docs/api/java/util/StringTokenizer.html

StringTokenizer is a legacy class that is retained for compatibility reasons although its use is discouraged in new code. It is recommended that anyone seeking this functionality use the split method of String or the java.util.regex package instead.

Bonsoir,

InputValue est une classe que nous implémentons qui permet simplement d'entrer du texte et de le stocker dans une variable.

Je dois faire avec les éléments que l'on me donne en cours, même si certains sont "outadated", malheureusement.

On m'a dit de toujours implémenter un constructeur sans paramètres, d'où le constructeur avec texte.

Quoi qu'il en soit, j'ai réussi à obtenir ce que je voulais. Mais je suis curieux de savoir ce que voulais tu que je fasses avec la méthode static, même si ce n'est pas totalement urgent.

import java.util.*;

public class StringSentence {
	
	private String sentence;
	private ArrayList <String> words;
	
	public StringSentence(){
		sentence = InputValue.readString("What chu say yo ? ");
		words = new ArrayList <String> ();
	}
	
	public StringSentence(String sentence){
		this.sentence = sentence;
		words = new ArrayList <String> ();
	}
	
	/* Call the StringTokenizer. hasMoreTokens is boolean, give true is there
	 * are other words. We store the next word into word variable, then print it.
	 */
	public void extractWords(){
		StringTokenizer mySent = new StringTokenizer(sentence);
		while (mySent.hasMoreTokens()){
			String word = mySent.nextToken();
			if (!words.contains(word)){
				words.add(word);
			}
			
		}
	}	
	public String toString(){
		return "Here what chu chose : " +sentence+ " \nAnd the array :\n" +words.toString();
	}
		
		
		
		

Et la classe Test :

import java.util.*;

public class TestStringSentence {

	public static void main(String[] args) {
		
		//It is possible to print the variable content directly calling the variable.
		String phrase = InputValue.readString("What chu say ? ");
		
		StringSentence jeDis = new StringSentence (phrase);
		
		jeDis.extractWords();
		
		System.out.println(jeDis);
		
		
		
		

Et comment fais tu pour faire de jolies fenêtres de code ? Histoire que ce soit plus sympa pour nous deux lorsque je posterai dorénavant du code...

Merci,

"On m'a dit de toujours implémenter un constructeur sans paramètres"
Mais dans ce cas tu devrais donner aucune valeur à sentence ou alors une valeur par défaut (null, "", etc.) mais en aucun cas solliciter l'utilisateur. Pour remplir la valeur après une initialisation avec le constructeur vide il faudrait appeler un setteur pour remplir la valeur (que tu n'as pas...)

"je suis curieux de savoir ce que voulais tu que je fasses avec la méthode static"
Actuellement ton code de test c'est ça :

String phrase = InputValue.readString("What chu say ? ");
StringSentence jeDis = new StringSentence (phrase);
jeDis.extractWords();
System.out.println(jeDis);

Éventuellement avec un constructeur par défaut ça donnerait ceci :

StringSentence jeDis = new StringSentence();
String phrase = InputValue.readString("What chu say ? ");
jeDis.setSentence(phrase);
jeDis.extractWords();
System.out.println(jeDis);

Avec une méthode static tu aurais ceci :

String phrase = InputValue.readString("What chu say ? ");
String result = StringSentence.extractWords(phrase);
System.out.println(result);

En effet, l'objet

jeDis

ne sert pas à grand chose au final, et dans ce cas la méthode statique est plus adaptée. Si je prends

InputValue.readString(...);

on aurait pu faire :

InputValue input = new Input("What chu say ? ");
input.readString();
String phrase = input.getValue();

Conceptuellement, c'est la même chose que ce que tu as fait avec StringSentence...
Mais c'est moche !

"comment fais tu pour faire de jolies fenêtres de code ?"
Tu peux sélectionner un langage spécifique lorsque tu mets les balises de codes :


Tu peux aussi le faire manuellement, en mettant <code java> ... </code>

Salut,

La méthode static me tente bien, mais je ne sais pas qu'est ce qui doit passer en static. Je veux dire, j'ai écrit :

String phrase = InputValue.readString("What chu say ? ");
String result = StringSentence.extractWords(phrase);
System.out.println(result);

Mais ca ne compile pas. J'ai voulu rendre static ma méthode extractWords, mais bien sur, elle ne fonctionne pas avec des variables non static.

Je suis donc perplexe...

Merci à toi !

Il faut réécrire tout ce que tu as mis dans ta classe StringSentence pour le mettre dans une seule méthode, c'est à dire faire l'initialisation de la liste, le passage de paramètres et le retour de résultat, tout en un seul traitement (éventuellement découpée en appel de sous-méthode)

public class StringSentence {
    
    public static List<String> extractWords(String sentence) {
        List<String> words = new ArrayList<String>();
        StringTokenizer mySent = new StringTokenizer(sentence);
        while (mySent.hasMoreTokens()) {
            String word = mySent.nextToken();
            if (!words.contains(word)) {
                words.add(word);
            }
        }
        return words;
    }

}

public class TestStringSentence {

    public static void main(String[] args) {
        String phrase = InputValue.readString("What chu say ?");
        List<String> words = StringSentence.extractWords(phrase);
        System.out.println("Here what chu chose : " +phrase+ " \nAnd the array :\n" + words);
    }

}

Remarque : je te conseilles d'éviter les "\n" dans les println, si tu veux revenir à la ligne, fais un autre println, on aura ainsi "\r\n" sous Windows, "\n" sous Linux, etc. mais pas un "\n" systématique.

Le super() est pour récupérer l'attribut "nom".

super

est implicite, même si tu ne le mets pas, l'attribut "nom" sera initialisé quand même.

à quoi correspond le terme entre <> dans les ArrayList ?
Il faut regarder dans la documentation : https://docs.oracle.com/javase/8/docs/api/java/util/List.html

Interface List<E>
Type Parameters:
E - the type of elements in this list

Lorsque je lui ai demandé de corriger l'élément qui l'empêchait de compiler add(), Eclipse a aussi eu la fabuleuse idée de créer un objet qui s'initierait de cette manière : Student CG1;
En effet, Eclipse a vu que tu faisais

marks.add(CG1)

, or dans une classe List<E>, la méthode add prend en paramètre un élément de type E, pas un double...
Puisque la liste est définie ArrayList<Student>, Java et donc Eclipse, attendent un add(Student) ce qui n'est possible que si CG1 est de type Student...

Donc ici ton problème c'est que ton ArrayList - qui représentent des notes - ne devraient pas être de type Student, mais de type Double.

private final List<Double> marksList = new ArrayList<Double>();

public Student(double...marks) {
    marksList = new ArrayList<Double>();
    for (double mark : marks)
        marksList.add(mark);
}

Je veux bien comprendre pour les éléments de type double, string etc.

Mais que veux dire ici : un élément de type Student ?

Tu as créé une classe Student, tu peux donc t'en servir pour créer des objets de type Student, sinon ça ne sert à rien de créer des classes...

Student st = new Student(12.1, 13.7, 11.6);

Bonjour,

Tu peux récupérer les exception/error avec la structure try/catch/finally
Catching and Handling Exceptions

Remarque : il est préférable quand c'est possible de faire des tests pour détecter le problème avant que l'exception ne soit provoquée. Par exemple tester qu'une valeur vaut null avec un if, plutôt que faire un catch sur NullPointerException.

C'est un peu chaud tout ça.... Mais j'y jetterais sûrement un coup d'oeil plus poussé un peu plus tard. En tout cas je saurais par où passer au cas où.

Et joyeux Noël !

while(a != "oui" | a != "non")

En Java les opérateurs == ou != permettent de comparer deux objets, pas leurs valeurs.
Tu peux avoir deux String de même valeurs : l'un écrit en dur dans le code, et l'autre obtenu par un readString, mais pourtant ce sont bien deux objets différents, ils seront donc toujours !=
Pour comparer des objets, et en particulier des String, il faut utiliser la méthode equals.

De plus : l'opérateur

|

existe en Java, mais il est plutôt utilisé pour le calcul de bits, pas pour les booléens. Du coup avec un

|

tu vas évaluer les deux conditions, à gauche et à droite, puis les calculer. Alors qu'en utilisant l'opérateur des booléens

||

si la condition à gauche est vraie, il n'aura pas besoin de calculer la condition de droite pour connaître le résultat total. Ça peut paraître pas grand chose dans ton cas, mais c'est vraiment important pour la suite (idem pour

&

et

&&

)

Enfin, attention : ta logique booléenne est mauvaise ce n'est pas tant que a différent de "oui" OU a différent de "non", mais tant que a différent de "oui" ET b différent de "non". Parce que sinon tu en auras toujours au moins des deux qui sera vrai (si a vaut "oui", b sera différent de "non", et inversement)

while (!a.equals("oui") && !a.equals("non"))

Tip top merci beaucoup !