J'ai créé le Design de l'appli mais je sèche totalement pour paramétrer les calculs que je veux faire.
Je voudrais que lorsque je clique sur le bouton "CALCULER" il y ai dans les cases "Total" le calcul suivant :
- si "%" coché alors : (Cases "colonne %" x Cases "Quantité total en gr.")/100
- si "gr." coché alors : (Cases "colonne gr." x 1)
J'aimerais aussi créer un message qui s'affiche lorsque :
- somme des "cases Total" = à case "Quantité totale en gr." alors "OK"
- sinon somme "cases Total" - "case Quantité" totale en gr."
Je voudrais que lorsque je clique sur le bouton "CALCULER" il y ai dans les cases "Total" le calcul suivant :
- si "%" coché alors : (Cases "colonne %" x Cases "Quantité total en gr.")/100
- si "gr." coché alors : (Cases "colonne gr." x 1)
ça donnerait un truc comme ça, non ?
var total = 0 if (radioButton1.isChecked) { // si la checkbox "%" est cochée // ici ton calcul val calcul = ... total += calcul } if (radioButton2.isChecked) { // si la checkbox "gr." est cochée // ici ton calcul val calcul = ... total += calcul }
Ceci, à mettre dans le
onClickListener()
du bouton.
Désolé, je ne vais pas être plus précis pour plusieurs raisons :
- je te conseille de renommer tes composants graphiques, tu vas te perdre avec les edit1, edit 2, edit 12, etc.
- je t'ai donné le squelette, le reste tu pourras le trouver par toi-même
J'ai renommé les composants graphiques mais j'arrive pas à mettre m'on idée en langage Kotlin. J'y arrive en langage Excel mais celui de Kotlin reste un mystère pour moi. Il dois y avoir des info essentielles qui m'échappent :-/
C'est simplifier au maximum :
un algo c'est des données stockés dans des variables. stock unique avec une variable basique typée. Par exemple, je veux stocker un age, c'est un nombre entier, la personne a 50 ans. Exemple en pseudo-code¹ :
Variable age de type ENTIER age = 50
C'est bien, mais, si on a 50 personnes, elles n'ont pas forcément toutes 50 ans. On peut donc avoir recours aux variables à stock multiple comme une liste, un tuple, un dictionnaire, etc. en langage Python 3. D'après https://kotlinlang.org/docs/reference/collections-overview.html il y en aurait 3 chez Kotlin : List, Set et Map. On peut pousser plus loin en faisant de la programmation orientée objet (POO) où l'on écrira une classe Humain par exemple, et on instanciera un objet par personne. Imagine tu veux instancier 2 objets Alice et Bob qui ont respectivement 40 et 50 ans :
CLASSE Humain: MÉTHODE Construire(ceci, nom, age): // ceci² ceci.nom = nom ceci.age = age alice = Construire("Alice", 40) bob = Construire("Bob", 50) écrire("Alice a {alice.age} ans.") // affiche à l'écran : Alice a 40 ans.
Bon, ce n'était que la partie ultra simplifiée du stockage de données
ensuite, viennent les conditions, les boucles, et les fonctions, et d'autres instructions ou opérations.
Quand dans ton algo, ta phrase commence par : "Si ..." ce sera une condition. Le résultat d'une condition est un booléen, c'est à dire une valeur vraie ou fausse. Il n'y a pas d'entre-deux en informatique. En informatique, ce qui est 99.99999999999... % vrai est... faux.
Exemple :
age = 30 SI age >= 18 ALORS : "personne majeure" SINON SI 0 <= age < 18 : "personne mineure" SINON : "personne inexistante"
L'ordi va effectuer ces opération :
il connaît la valeur de
age
qui est 30.
1) il vérifie 30 >= 18 : c'est vrai. age >= 18 se transforme en VRAI. Dans ce cas, c'est l'instruction correspondante qui est effectuée, il affiche donc "personne majeure".
Change 30 par 15. Il vérifie 15 >= 18 : FAUX. Il passe à la condition suivante et la vérifie : 0 <= 15 < 18 : VRAI. L'instruction correspondante est effectuée : "personne mineure". Remplace 15 par -500. -500 >= 18 ? FAUX ; 0 <= -500 < 18 ? FAUX. SINON n'a pas de condition car il implique tout le reste, et -500 entre dans cette catégorie : "personne inexistante". Dans mon exemple, pour un être-humain, mettre un âge de 95412364 ans est absurde. Pour l'ordinateur, il ne fera que vérifier : 95412364 >= 18 : VRAI : "personne majeure"
Une boucle c'est relativement simple à comprendre, mais, peut être dangereux à l'usage en cas de fabrication d'une boucle infinie. On sort d'une boucle quand la condition est fausse.
Exemple :
nombre = 0 TANT QUE nombre < 10: écrire({nombre}) nombre = nombre + 1 // absurde en maths, logique en programmation
on verra : 0 puis 1 ... 9 et la boucle s'arrête. 9 deviendra 10. 10 < 10 : FAUX, on sort de la boucle. Commente ou retire la ligne nombre = nombre + 1, tu verras : 0, 0, 0, ..., 0... sans interruption, c'est une boucle infinie.
Tu auras forcément des portions de code dont le squelette se répète, faire une fonction de ce squelette est très utile pour simplifier la lecture et la manipulation du code ultérieurement. Désolé pour l'exemple un poil compliqué. Imagine tu veux que l'ordinateur t'affiche la dernière ligne de 50 fichiers, bêtement nommé fichier_1 à fichier_50. À première vue on ferait quelque chose comme :
Ouvrir("fichier_1", mode LECTURE) placer curseur en début de la dernière ligne écrire(début=curseur, fin=fin du fichier) Fermer("fichier_1")
Ceci 50 fois, donc 200 lignes. On fait une fonction. Dans les 4 lignes, seul le premier paramètre d'OUVRIR varie, pareil pour FERMER. Dans la fonction, il n'y aura donc qu'un paramètre d'entrée, c'est le fichier, nommons ce paramètre fichier. Et nommons la fonction Afficher_derniere_ligne :
FONCTION Affiche_derniere_ligne(fichier): Ouvrir(fichier, mode LECTURE) placer curseur en début de la dernière ligne écrire(début=curseur, fin=fin du fichier) fermer(fichier) Afficher_derniere_ligne("fichier_1) [...] Afficher_derniere_ligne("fichier_50)
5 lignes + 50 x 1 lignes = 55 lignes.
Tu as 10 fichiers supplémentaires ? Dans le premier cas, tu devras écrire 10 x 4 lignes. Dans le second, 10 x 1 ligne.
Tu dois maintenir le code source, modifier une opération car tu ne veux plus la dernière ligne mais les 5 dernières lignes. Dans le premier cas, tu vas devoir faire 50 manipulations. Dans le second cas, tu peux faire un rechercher remplacer :
Afficher_derniere_ligne
en
Afficher_5_dernieres_lignes
et tu remplaces une seule fois :
placer curseur en début de la dernière ligne
en
placer curseur en début de la cinquième ligne en partant de la fin
.
¹ Le pseudo-code est un code inutilisable mais lisible, on utilise des conventions connues ou alors on les précise en amont pour faciliter la lecture aux personnes extérieures si nécessaire.
² ceci est un terme clé ou arbitraire qui signifie l'objet lui-même. Tu auras remarqué que la méthode Construire a 3 paramètres : ceci, nom et age, or quand on l'utilise, on n'utilise pas explicitement le paramètre ceci. En fait, ceci correspond à alice dans la construction de l'instance alice, et à bob dans celle de bob. Dans des langages on a this, dans d'autre on a self.
Merci pour la réponse mais je crois que je me suis lancé dans un truc qui me dépasse. J'ai fait les exemples dans codelab et my first app, mais a part recopier ce qu'ils disent c'est tout ce que je fais. Je ne trouve pas le point commun entre chaque exemple et encore moins avec ce que je voulais faire. Je pense qu'il faut déjà connaître le codage info pour y comprendre quelque chose, dommage...
D'accord, je vais essayer de mettre des mots clés sur le problème que tu présentes. Tu parles d'algorithmique. C'est la création et donc la méthode pour construire des algorithmes.
Il peut y avoir plusieurs algorithmes pour une finalité. Exemple : je veux parcourir tous les éléments d'une liste. On peut partir du début à la fin ou de la fin au début, ou du 3ème élément et on parcourt de manière ascendante ou descendante. Maintenant, quel est le parcours le plus logique pour un humain ? Le parcours du début à la fin. En algorithme ça donnerait :
Liste = [élément 1, élément 2, ..., élément n] compteur = 1 TANT QUE compteur <= n: lire(élément compteur) compteur = compteur + 1
Les langages populaires ont un système de parcours d'élément qu'on appelle le POUR CHAQUE :
Liste = [élément 1, élément 2, ..., élément n] POUR CHAQUE élément de Liste: lire(élément)
Les 2 codes font les mêmes opérations.
Le mieux serait que tu t'entraînes sur des choses du quotidien.
Par exemple, je décide, lors des provisions, de me rapprocher de 80 % du ticket de caisse pour des produits indispensables, et 20 % pour des produits dispensables. Je vais faire les courses, j'ai un ticket de 100 €. J'ai 30 produits. Sur un cahier, j'identifie les produits par sa position sur le ticket, donc, de 1 à 30, par la nécessité et par le prix. J'aurai sur le cahier :
PRODUIT | NÉCESSAIRE |PRIX 1 | OUI | 2€ 2 | NON | 6€ ... 30 | NON | 4€
Ensuite, je vais créer 2 listes. Une liste que je vais nommer
produits_indispensables
et une autre
produits_plaisir
à l'intérieur de ces listes, les éléments qu'elles contiendront seront pour la première, le PRIX de chaque PRODUIT dont NÉCESSAIRE est à OUI et le PRIX de chaque PRODUIT dont NÉCESSAIRE est à NON pour la seconde liste :
Ensuite, je veux la somme cumulée de chaque liste et surtout, stocker ces résultats. Pour ensuite, additionner ces 2 résultats, et donc, vérifier que ça fait bien 100 €. Je veux aussi vérifier le pourcentage.
1) Je dois savoir comment on fait une somme cumulée. Pas besoin d'ordinateur, on part de 0, on ajoute la valeur de chaque élément, à la fin du parcours des éléments on a une valeur X. Sur [1,5,3] on obtient 0 + 1 + 5 + 3 = 9. En code :
liste = [1, 5, 3] valeur_cumulée = 0 POUR CHAQUE élément de liste: valeur_cumulée = valeur_cumulée + élément afficher(valeur_cumulée) // affichera : 9
Pour avoir la somme des 2 valeurs cumulées. Autant faire une fonction :
FONCTION somme_cumulée(liste): valeur_cumulée = 0 POUR CHAQUE élément de liste: valeur_cumulée = valeur_cumulée + élément RETOURNER valeur_cumulée liste_1 = [1, 5, 3] liste_2 = [1, 3, 7] total_liste_1 = somme_cumulée(liste_1) total_liste_2 = somme_cumulée(liste_2)
Le terme RETOURNER est important pour le stockage dans les variables
total_liste_1
et
total_liste_2
car c'est la valeur de sortie de la fonction
somme_cumulée
Bon, on sait comment faire une somme cumulée. On additionne simplement :
grand_total = total_liste_1 + total_liste_2
Enfin, on s'attaque au pourcentage afin de vérifier le respect du 80/20. Encore une fonction :
FONCTION pourcentage(valeur, total): résultat = valeur * 100 / total RETOURNER résultat pourcentage_produits_nécessaires = pourcentage(total_liste_1, grand_total) pourcentage_produits_plaisir = pourcentage(total_liste_2, grand_total)
Tu peux lire le résultat et vérifier le 80/20.
Que ça te paraisse laborieux ou non, la chose la plus importante qui fait progresser et donne envie de continuer c'est la récompense.
J'ai fait mon algorithme pour vérifier le 80/20 après mes premières courses. AVANT de lancer les opérations, je me dis par exemple : "Je peux dépenser 50 € pour le plaisir. Si je dépasse 90 %, je m'octroie le droit de dépenser les 50 €. Si je suis entre 80 et 90%, je dépense 40 € et préserve 10 €..." Ainsi de suite.
Pour calculer le total en fonction des listes : if "boutton % coché" valeur_cumulé = 0 POUR CHAQUE élément de liste quantité_poucent : valeur liste total = )valeur quantité_Totale * valeur quantité_pourcent) /100 RETOURNER (valeur_cumulée)
if "boutton gr. coché" valeur_cumulé = 0 POUR CHAQUE élément de liste quantité_gr : valeur liste total = valeur quantité_gr * 1 RETOURNER (valeur_cumulée)
Pour avoir la somme des valeurs cumulées de la liste resultat :
FONCTION somme-cumulée(liste) : valeur_cumulée = 0 POUR CHAQUE élément de liste : valeur_cumulée = valeur_cumulée + élément RETOURNER valeur_cumulée liste resultat_quantité = [A3, B3, ..., I3] total_resultat_quantité = somme_cumulée(resultat_quantité)
Pour vérifier le respect que resultat_quantité est = à quatité_Total :
FONCTION pourcentage(valeur, total): résultat = valeur * 100 / total RETOURNER résultat pourcentage_resultat_quantité = pourcentage(quantité_totale)
Pour une lecture plus agréable, je te conseille d'ouvrir un éditeur de texte, tu peux télécharger notapad++ qui est libre, gratuit, apprécié, et facile à utiliser : https://notepad-plus-plus.org/downloads/ Avec ce logiciel, tu écris ton algorithme, et tu penses à indenter certaines lignes, quand tu as lu, dans mes algorithmes, des lignes qui ne démarrent qu'après quelques espaces, il y en 4, c'est une convention, c'est une indentation de 4 espaces. Quand tu as l'algo, tu te places dans le champs de réponse, tu cliques sur l'icône
<>
à côté du
S
de souligner, tu colles l'algo, et l'indentation sera respectée.
Il faut bien faire attention au signe d'affectation et au signe de comparaison d'égalité. Je vois que tu as écris :
C'est le fondement que tu as choisis, il est correct, mais, il faut le respecter car c'est la base de ton algorithme. Il faut savoir qu'il n'y a aucun fondement toujours meilleur qu'un autre. Ça dépend de ce que l'on souhaite faire. Il est normal de le modifier et de rectifier en cours de route. Ça arrive quand on se dit : "Je veux faire cette opération mais avec cette base, je n'y arrive pas.", c'est pas grave. On n'évitera pas la prise de tête, mais, on peut éviter la migraine en faisant de la programmation modulaire. C'est une programmation qui rend chaque opération indépendante les unes des autres et on les relie entre elles par les paramètres d'entrée et de sortie des fonctions. Les paramètres d'entrée sont les paramètres dont une fonction a besoin pour effectuer des opération. Le résultat est le paramètre de sortie. Ça paraît compliqué, mais, en progressant, tu verras que ça te facilitera les futures tâches. De toute façon, le premier algorithme est améliorable, et le suivant, etc. On arrête d'améliorer quand le résultat nous satisfait et en second lieu, quand la vitesse d'exécution est rapide et que la quantité de mémoire est faible. Ça rend un algorithme efficace, mais, tu n'en es pas là. Tu dois te concentrer sur le respect du résultat.
Pour calculer le total en fonction des listes :
if "boutton % coché" valeur_cumulé = 0 POUR CHAQUE élément de liste quantité_poucent : valeur liste total = )valeur quantité_Totale * valeur quantité_pourcent) /100 RETOURNER (valeur_cumulée)
Ici, tu mélanges les instructions, tu as une condition, un code classique et une étape d'une fonction qui n'existe pas. RETOURNER est l'étape qui affecte une valeur au paramètres de sortie. Dans :
FONCTION pourcentage(valeur, total): résultat = valeur * 100 / total RETOURNER résultat
la variable résultat n'existe QUE dans la fonction pourcentage(valeur, total). On affecte le calcul à ce paramètre de sortie. Quand on continue dans le code principal, on peut donner un autre nom comme variable et l'affectation sera l'appel de la fonction. On appelle une fonction comme ceci généralement :
FONCTION somme-cumulée(liste) : valeur_cumulée = 0 POUR CHAQUE élément de liste : valeur_cumulée = valeur_cumulée + élément RETOURNER valeur_cumulée liste resultat_quantité = [A3, B3, ..., I3] total_resultat_quantité = somme_cumulée(resultat_quantité)
C'est franchement pas mal, l'idée est là. Mais, tu ne respectes pas l'indentation. Petit bémol, plus haut dans ton message, tu as une liste de A3 à I3 qui est dans le code principal, c'est une liste réutilisable. Réécrire la liste plus loin, comme ici, est inutile. C'est quand même le meilleur code proposé jusqu'ici, bravo !
FONCTION pourcentage(valeur, total): résultat = valeur * 100 / total RETOURNER résultat pourcentage_resultat_quantité = pourcentage(quantité_totale)
aïe ! C'est moins bien. Déjà, la dernière ligne signifie que tu affectes à
pourcentage_resultat_quantité
la valeur du paramètre de sortie de la fonction
pourcentage
. Et j'ai du mal à savoir si c'est ce que tu veux faire. Ou alors, tu veux comparer que la valeur de sortie de la fonction
pourcentage
soit bien égale au
poucentage_resultat_quantité
. Dans le premier cas, c'est ok mais il y a un hic. Dans le second cas, ce n'est pas le bon signe qui est utilisé.
Le hic est simple. Quand tu as construis la fonction
pourcentage
, tu lui as donné 2 paramètres d'entrée :
valeur
et
total
. Puis, quand tu as appelé la fonction, tu ne lui as donné qu'un seul argument de paramètre d'entrée, or, il en faut 2. Je pense que tu as oublié le premier paramètre
valeur
et comme argument tu dois mettre une valeur d'une case. Pour ne pas te perdre entre paramètre et argument. Le paramètre c'est le nom qu'on donne dans la parenthèse de la construction d'une fonction, l'argument c'est la valeur que l'on affecte au paramètre correspondant. Dans ton code,
valeur
est le paramètre numéro 1 d'entrée,
quantité_totale
est l'argument de ce paramètre parce que l'ordinateur lit de le code de gauche à droite. Il va t'envoyer une erreur comme :
"La fonction a 2 paramètres. Je ne reçois qu'un argument. Il manque un autre argument."
Pour résumer, tu dois respecter la cohérence des instructions tout le long de ton code :
- pas besoin de réaffecter avec les mêmes valeurs une variable
- avoir autant d'arguments que de paramètres
Pour le code XML, je ne saurais t'aider. Je sais que c'est le code qui gère le positionnement des graphiques de l'application. Je suppose que tu utilises le gestionnaire visuel et ce XML est auto-généré par ordinateur.
En revanche, pour revenir au problème initial. Selon la case coché, effectuer tel calcul. Tu as 2 cases à cocher, donc, tu peux créer 2 variables. Tu dois décider quelle case est cochée dès l'ouverture de l'application. Logiquement, on peut choisir la case la plus à gauche. La case la plus à gauche est %. Le problème c'est qu'avec un code retranscrit pour l'ordinateur de :
if "boutton % coché"
l'ordinateur ne va pas comprendre. Pour qu'il comprenne, il faut utiliser les variables booléennes, du nom du mathématicien George Boole. Elles ne font pas peur, ce sont, sans doute, les variables, les plus puissantes car très rapides et légères en mémoire. On les connaît avec leur 2 uniques valeurs :
VRAI
ou
FAUX
. C'est tout. Et pour info, en informatique, je le répète, ce qui est 99.99999999999... % VRAI est... FAUX. On reprend, on décide qu'à l'ouverture de l'appli, la case % est visuellement cochée. Il faut en informer l'ordinateur car il distingue le visuel du code. On a 2 case à cocher, créons 2 variables :
coche_pourcentage coche_gr
On sait que visuellement, la case % est cochée, et que la case gr n'est pas coché. On fait le parallèle, coché, ça veut dire VRAI, pas coché, ça veut dire FAUX, donc :
coche_pourcentage = VRAI coche_gr = FAUX
Enfin, il faut connaître le fonctionnement entre la partie graphique et la partie calcul (le code) pour savoir comment modifier les coches.
Je me permets juste une petite remarque: Adeline, as-tu conscience que le fichier xml ne fait pas tout ? Il décrit ton interface graphique, ok, mais derrière, il te faut de l'intelligence, du code en Java ou en Kotlin. Tu en as conscience ? Je ne vois pas un seul bout de code...
Je peux comprendre qu'en ayant quotidiennement et toujours sur soi son smartphone, on est davantage tenté de faire une appli smartphone qu'un logiciel sur PC. Mais, honnêtement, créer une appli, pour un débutant, c'est une vraie usine à gaz. Kotlin est un assez jeune langage qui hérite encore de beaucoup d'instructions de Java. Ça implique d'apprendre 2 langages.
Je vois que ton objectif est de comprendre comment ça marche. Dans ce cas, je te conseille d'apprendre la partie graphique et la partie calcul (ou intelligence) de manière séparée. Je peux te conseiller ce cours d'algorithme : http://pise.info/algo/codage.htm n'hésite pas si tu as des questions. Je ne vais pas te conseiller nommément un langage de programmation, tu peux rester sur Kotlin, mais, il faudra voir Java également. La base de différents langages avec paradigme (façon) de programmation similaire est juste différente au niveau de la syntaxe. En gros, une fois que tu as bien appris la base d'un langage X, tu apprendras les bases d'un langage Y en un temps très court.
En vrai, peut importe que tu développes pour un PC, un serveur, un smartphone, un circuit imprimé, etc. La difficulté se trouve trouve dans l'apprentissage du 1er langage. Après, c'est presque comme une nouvelle langue vivante : la base est là, c'est juste une question de vocabulaire et de syntaxe.
Kotlin est un assez jeune langage qui hérite encore de beaucoup d'instructions de Java. Ça implique d'apprendre 2 langages.
Je ne suis pas d'accord...On peut très bien coder en Kotlin sans connaître Java, mais ce n'est pas le sujet ici ;)
En tout cas c'est bien compliqué. Quand Google dit que c'est à la portée de tout le monde de développer une appli c'est moyennement vrai. Certes, ils fournissent les outils mais les reste est laborieux quand on connais pas.
Bien sûr, il faut un minimum de connaissance... c'est comme tout : la cuisine, le vélo, le bricolage, etc. Au début, ce n'est pas facile mais après quelques temps, on s'y fait bien ;)
Je pense que le problème est moins dans la difficulté d'apprentissage que dans les outils à utiliser. Concrètement, si on veut créer un logiciel pour PC, on peut utiliser le langage Python 3 et le module Tkinter pour l'interface graphique. Si on connaît Python, on peut utiliser tkinter. pour une app mobile, on prend Kotlin pour les calculs de l'app, et XML pour l'interface graphique, 2 langages totalement différents, le premier de programmation, le deuxième de balisage.
Hier, j'ai fait quelques menues recherches sur les pré-requis de Kotlin. Ça provenait de tutorialspoint, pas le site officiel, qui avait mis Java en pré-requis, et pour XML, ils avaient mis HTML et Javascript. En admettant qu'ils aient raison, pour faire un logiciel PC : Python et c'est tout (ou un autre langage). Pour faire une app mobile : Kotlin + XML (pré-requis : Java, HTML, JS). Bien que je suis d'accord avec Bruno, on peut apprendre Kotlin sans Java en amont. Je m'étais fait cette remarque car j'ai eu un mal fou à trouver la fonction qui demande à l'utilisateur de taper au clavier. C'est readLine() qui est une fonction de Java.
Donc, on peut commencer "simple" avec un langage davantage pour PC pour avoir une base correcte. Ou "compliqué", en apprenant différentes technologies. Et comme qui peut le plus peut le moins...
As-tu ouvert et commencé à lire ce cours : http://pise.info/algo/codage.htm ? Il utilise une autre convention pour affecter, par exemple, la valeur entière
50
à la variable
age
:
VARIABLES age <- 50 FIN VARIABLES
Tu utilises le signe
=
pour l'affectation. Or, à la ligne :
si resultat_quantité = quantité_totale alors
tu utilises aussi le signe
=
pour la comparaison. Dans certains langages de programmation, on compare l'égalité avec le signe
=
doublé :
==
Tu peux utiliser cette convention.
Mais, je te conseille d'annoter en amont ta propre convention par exemple au début de chaque algorithme tu pourrais faire :
CONVENTION
J'utilise le signe = pour l'affectation. Exemple : age = 50 signifie j'affecte la valeur 50 à la variable age ;
J'utilise le double signe == pour la comparaison d'égalité. Exemple : age == 50 signifie je compare la valeur de la variable age à l'entier 50 ;
Pour la boucle TANT QUE, j'écris :
TANT QUE condition(s) FAIRE :
instructions
FIN TANT QUE
[...]
FIN CONVENTION
Revenons à cette ligne
si resultat_quantité = quantité_totale alors
étant donné que tu utilise
=
pour l'affectation. Il faut savoir que les booléens sont tellement puissants que les conditions d'une instructions
SI
se transforment TOUJOURS en booléen. La valeur entière
0
vaut
FAUX
en booléen, et toute autre valeur (1, -1, 542; -4412, ...) vaut
VRAI
. Voici 2 exemples simples pour te montrer l'erreur d'utilisation de signe :
valeur = 0 SI valeur = 0 ALORS: "La valeur vaut 0." SINON: "La valeur ne vaut pas 0."
Voilà ce qui se passe, si le programme qui lit le code (le compilateur) ne détecte pas l'erreur :
on affecte la valeur 0 à la variable valeur. L'ordinateur va lire la condition SI comme suit :
SI ; valeur = 0 se transforme en FAUX ; ALORS: après transformation l'ordinateur a :
SI FAUX ALORS:
, donc le résultat sera : "La valeur ne vaut pas 0."
Maintenant :
valeur = 0 SI valeur == 0 ALORS: "La valeur vaut 0." SINON: "La valeur ne vaut pas 0."
Lors de la condition
SI
l'ordinateur fait : SI ; valeur == 0 => existe-t-il une variable
valeur
? OUI, quelle est sa valeur lors de l'affectation ? 0, est-ce que ce 0 de l'affectation est égal au 0 de la condition ? Oui, on transforme valeur == 0 en VRAI. Résultat : "La valeur vaut 0."
Ensuite, il faut que tu penses à indenter l'algorithme pour une lecture plus simple. De plus, certains langages obligent à indenter. L'évolution de ton algorithme est bonne, il y a des lacunes, surtout logiques, mais, c'est pas mal du tout. Dans la ligne :
lire coche_pourcantage, coche_gr
je pense que tu cherches à savoir quels sont les cases cochées. De manière littérale :
J'ai 2 cases : % et gr, si la première est coché j'effectue le calcul "calcul %", si c'est la deuxième, j'effectue le calcul "calcul gr"
devient en algorithme :
VARIABLES case_pourcentage = VRAI # commentaire : à l'ouverture de l'application, la case % sera cochée case_gr = FAUX # commentaire : à l'ouverture de l'application, la case gr sera décochée FIN VARIABLES CODE SI code_pourcentage ALORS : # rappel : l'ordi transforme en booléen toute comparaison, ici le booléen sera VRAI "calcul %" SINON SI code_gr ALORS : "calcul gr" SINON : "erreur : aucun calcul possible." FIN SI FIN CODE
"Je comprends pas valeur = 0. La valeur de quelle donné ? Quantité_totale ?"
Si tu parles de ce pasage :
Revenons à cette ligne
si resultat_quantité = quantité_totale alors
étant donné que tu utilise
=
pour l'affectation. Il faut savoir que les booléens sont tellement puissants que les conditions d'une instructions
SI
se transforment TOUJOURS en booléen. La valeur entière
0
vaut
FAUX
en booléen, et toute autre valeur (1, -1, 542; -4412, ...) vaut
VRAI
. Voici 2 exemples simples pour te montrer l'erreur d'utilisation de signe :
valeur = 0 SI valeur = 0 ALORS: "La valeur vaut 0." SINON: "La valeur ne vaut pas 0."
Voilà ce qui se passe, si le programme qui lit le code (le compilateur) ne détecte pas l'erreur : on affecte la valeur 0 à la variable valeur. L'ordinateur va lire la condition SI comme suit : SI ; valeur = 0 se transforme en FAUX ; ALORS: après transformation l'ordinateur a :
SI FAUX ALORS:
, donc le résultat sera : "La valeur ne vaut pas 0." Maintenant :
valeur = 0 SI valeur == 0 ALORS: "La valeur vaut 0." SINON: "La valeur ne vaut pas 0."
Lors de la condition
SI
l'ordinateur fait : SI ; valeur == 0 => existe-t-il une variable
valeur
? OUI, quelle est sa valeur lors de l'affectation ? 0, est-ce que ce 0 de l'affectation est égal au 0 de la condition ? Oui, on transforme valeur == 0 en VRAI. Résultat : "La valeur vaut 0."
Je n'ai pas été très clair. L'exemple que je prends avec la variable
valeur
est indépendante de ton algorithme. C'était pour te faire remarquer qu'on n'utilise jamais le même signe pour l'affectation et la comparaison d'égalité. Ce sont 2 opérations différentes donc il faut 2 signes différents
"Si quantité_totale = 0 alors ne rien faire sinon calculer ? "
Même erreur que plus haut, mauvais choix du signe pour la comparaison d'égalité.
Je pense que tu saisis mal les subtilités car tu n'as peut-être pas encore commencé l'apprentissage d'un langage de programmation.
Début Lire resultat_quantité
Si resultat_quantité == quantité_totale alors Écrire "Formule ok" sinon Écrire "Différence de" quantité_totale - resultat_quantité
Fin
C'est beaucoup mieux oui. Ça coule peut-être de source pour toi, mais, il faut bien déterminer et fixer le point de vue de ton pseudo-code. Ici, on voit qu'on se place sur le point de vue du pseudo-code et non de l'utilisateur. La ligne
Lire resultat_quantité
signifie que le code attend un valeur tapée au clavier et les lignes commençant par
Écrire
signifie que le code va afficher à l'écran ce qui suit entre guillemets ainsi que la valeur d'une variable ou d'une opération comme
quantité_totale - resultat_quantité
.
Je viens de télécharger VS Code sur Linux, c'est franchement un bon IDE. De plus, s'il manque une extension, VS Code te la propose au téléchargement.
C'est la 3ème fois que je dois te le dire, mais, tu gagneras en lisibilité et pour toi et pour les autres si tu postes en utilisant la balise code du site. Plusieurs méthodes pour l'utiliser, mais, une que je trouve simple :
tu tapes ton code ou algorithme dans un éditeur de texte. Bloc-Notes n'est pas conseillé, je t'ai suggéré Notepad++, mais, VS Code peut parfaitement servir d'éditeur de texte. Tu indentes le code ou l'algorithme. Une fois que c'est fait, tu le sélectionnes et le copies. Dans CCM, tu cliques sur l'icône <> et tu fais ctrl+v.
Et lorsque tu posteras du code Kotlin, il n'y a pas (encore ?) l'attribut Kotlin, mais, Java s'en rapproche le plus pour avoir une couleur syntaxique agréable et correcte.
En tout cas, tu progresses bien. Pense bien à attaquer un langage de programmation, tu apprendras les mécanismes et tu comprendras plus facilement les subtilités comme la différence entre l'affectation et la comparaison d'égalité.
. Avant d'écrire l'algorithme juste au dessus (qui est faut vue que
resultat_quantité
ne sera pas tapé au clavier mais calculé par l'appli) je ne devrais pas écrire un algorithme qui va additionner la liste ? c'est pas avec cette histoire de RETOURNER ?
C'est très bien que tu voies tes erreurs. C'est normal d'en faire et c'est le processus normal de progression. On essaye, ça rate, on modifie un élément, on réessaye, ça rate mais, c'est mieux ou c'est pire, on réadapte, et ainsi de suite jusqu'à ce qu'on obtienne satisfaction.
En revanche, tu dois être plus rigoureuse quant à l'utilisation des termes. Quand tu parles d'algorithme qui va additionner la liste puis de "l'histoire" de RETOURNER, tu parles, en fait, d'une fonction. Une fonction fait partie des divers éléments que composent un algorithme.
Tu en es où de l'apprentissage de Kotlin ? Je n'ai pas vérifié, mais, c'est quasiment sûr qu'il existe une fonction qui calcule le cumul des éléments d'une liste. N'hésite pas à utiliser ton pseudo-code et Kotlin en parallèle pour écrire ton algorithme.
Instancier signifie construire un objet selon le modèle de construction de la classe utilisée.
Comme ta liste ne contient que des nombres, il est logique que tu utilises la classe
IntArray
et pour instancier
intArrayOf
.
Kotlin est un langage qui peut être orienté objet. C'est un paradigme de programmation. Ce type de programmation permet de manipuler l'objet instanciée en utilisant des fonctions internes à la classe.
Si ta méthode d'apprentissage de Kotlin c'est : "Je veux tel élément pour mon créer mon appli. Je vais chercher comment on fait en Kotlin." Tu cours à l'échec assuré, ta vas te dégoûter.
Mieux vaut apprendre les bases, programiz Kotlin a l'air pas trop mal. Tu lis, apprends et comprends chaque partie de leur tuto. kotlinlang doit être un support annexe. Les documentations de langage de programmation sont assez imbuvables parce qu'il y a tout mais il faut savoir chercher. Et pour savoir, il faut pratiquer, et pour pratiquer, les tutos ne sont jamais complets, mais, souvent suffisants.
concerne des données figées. Je n'arrive pas a comprendre ce que signifie
Int
. Il revient souvent, tout comme
Strings
mais là je crois que ça fait référence à du texte.
intArrayOf(1, 2, 3)
, c'est le tableau avec la ligne 1, 2 et 3. Donc, je dirais que ton tableau s'appelle x avec 3 lignes. Dans les exemples que je vois les variables sont déjà connues à l'avance et figées. Je ne trouve pas d'exemple lorsque les variables ne sont pas connues et où elles peuvent changer constamment.
"Je ne trouve pas d'exemple lorsque les variables ne sont pas connues et où elles peuvent changer constamment."
Fais des tests. Créer 2 variables, une avec le mot clé
var
l'autre avec le mot clé
val
, modifie les valeurs, exécute le code et constate.
Début Lire coche_poucentage, coche_gr Si coche_poucentage = vrai alors Ecrire quantité_totale * quantité_pourcent / 100 sinon Ecrire quantité_gr FinSi Fin
Début val Tableau: IntArray = intArrayOf(1,2,3,4,5,6,7,8,9) // j'ai pas encore approfondi le sujet Faire la somme de Tableau Fin
Début TantQue resultat_quantité == somme Tableau alors Ecrire "Formule correcte" sinon Ecrire "Différence de" (quantité_totale - somme Tableau)/quantité_totale * 100 FinTantQue Fin
Et j'ai codé une version très simplifiée du dernier algorithme pour m'entrainer mais je n'arrive pas à avoir le bon résultat s'il y a un écart, (c'est peut être parce que kotlin aime bien les chiffres ronds ?) :
var quantité_pourcent = 2 var quantité_gr = 15 var resultat_quantité = 80 var quantité_totale = 150
fun main(){ if (resultat_quantité == quantité_totale) { print("formule correcte") } else { print ("Ecart de ") var ecart1 = (quantité_totale.minus(resultat_quantité)) //le calcul de cette ligne est correct. var ecart2 = (ecart1.div(quantité_totale)) // le calcul de cette ligne est faux, il devrait donner 0.4666... et non 0. var ecart3 = (ecart2.times(100)) // forcement faux puisque ecart2 est faux, devait donner 46.666. print ("$ecart3 %") // devrait donner 46.66...%
Ce n'est pas Kotlin qui n'aime que les nombres entiers. Un langage de programmation n'est que l'outil de communication entre l'humain et l'ordinateur, dans le sens humain-ordi. Après, d'autres logiciels entrent dans la danse, enfin, surtout un, le compilateur. Un compilateur est un logiciel complexe mais, on pourrait faire une sorte d'analogie avec le traducteur. Un auteur écrit un livre dans une langue A, le traducteur qui connaît la langue A et B, va lire dans la langue A puis écrire dans la langue B. Le compilateur a des degrés de permissions, on peut le configurer.
Donc, que fait le compilateur ? Il traduit de Kotlin vers un langage d'instructions compréhensible pour le processeur de ton ordinateur.
La compréhension des chiffres par l'ordinateur se fait en base binaire. Le fameux bit que tu as dû entendre parler : Internet avec 100 Méga bits par seconde. Une des plus grosses préoccupation des constructeurs de processeurs c'est comment gérer et être le plus performant possible avec les nombres décimaux. Parce qu'un nombre s'écrit comme ceci dans le compilateur : 10 en base 10 vaut : 1010 en base 2 : 1*2³ + 0*2² + 1*2¹ + 0*2⁰ = 8 + 0 + 2 + 0 = 10. Le nombre 10.5 se notera : pareil que 10 pour la partie entière et 0.5 c'est : 1*2⁻1 soit 1/2¹ = 0.5.
Mais pour obtenir 0.46, c'est 0.25 + 0.125 + 0.0625 = 0.4375, et il faut continuer jusqu'à obtenir la valeur la plus proche. Parfois cette valeur proche n'est pas égale à la valeur voulue.
Comment y remédier ?
La méthode simpliste mais qui n'aura pas forcément une efficacité totale : changer le type de décimal, passer du type
float
au type
double
, généralement le premier est codé sur 32 bits, et le second sur 64, donc, le second offre un nombre beaucoup plus précis. Problème, les processeurs sont ultra rapides avec les nombres entiers, ils le sont beaucoup moins avec les nombres décimaux. C'est relatif quand même.
La méthode qui consiste à travailler le plus longtemps possible avec des nombres entiers. Mettre les prix en centimes d'euros pour les calculs, et les convertir en euros pour l'affichage. Je te conseille cette méthode.
Je vois que tu utilises les méthodes¹ pour les opérations de calcul :
x.minus()
,
x.div()
. Tu peux rester classique et utiliser les signes de calcul :
en Kotlin. Par contre, si un des nombres de l'opération est décimal alors le résultat est décimal :
5 / 2.0 = 2.5
en Kotlin.
Il n'y a pas de cours de Kotlin, mais, le site http://www.france-ioi.org/algo/chapters.php est vraiment bien pour travailler l'apprentissage et l'entraînement sur les algorithmes. Le langage le plus proche est Java pour Kotlin, sinon, tu peux coder en Python, mais, tu peux utiliser le langage JavaScool. Tu t'inscris et tu fais les activités dans l'ordre, tu comprendras mieux le fonctionnement des programmes sans entrer dans les coulisses.
Pour les codes Kotlin, je te suggère de sélectionner l'option java pour avoir une coloration syntaxique et les numéros de lignes. Ce sera plus agréable à lire et on pourra mieux t'indiquer l'emplacement des problèmes.
Je recopie ton code :
fun main(){
val x: IntArray = intArrayOf(1, 2, 3)
fun IntArray.sum(): Int {
var sum = 0
for(Int in x) {
sum += Int
}
return sum
}
}
Tout d'abord l'indentation doit être cohérente. Elle est, certes, facultative avec kotlin, mais conseillée avec 4 espaces : https://kotlinlang.org/docs/reference/coding-conventions.html#formatting . Dans ton code, ligne 2 tu as 1 espace, puis ligne 4, tu en as 4.
Ligne 2 : le nom de la variable est
x
et non
IntArray
car à la ligne 3, tu n'utilises pas la bonne variable, et si tu n'as pas d'erreur c'est sans doute parce que tu as écrasé la méthode¹
à la ligne 3, et Int aux lignes 5 et 6 comme des variables. Il faut vraiment éviter d'utiliser les mots clés comme variables. Kotlin a l'air permissif car d'autres langages interdisent ce type d'action. Une variable c'est toi qui la nommes.
Si on passe sur la forme qui reste importante. Pourquoi il n'y a pas d'erreur dans ton code ?
Ton code est "correct" mais il ne fait rien. Tu n'as fait que définir, c'est-à-dire, écrire le constructeur de la fonction. Prenons l'analogie des coordonnées téléphoniques. Tu prends le numéro de Michel Dupond et l'enregistres. Ça ne va pas appeler, c'est toi qui dois appuyer sur le bouton appeler. C'est un peu pareil avec les fonctions en programmation informatique. Dans ton code, tu as mal écrit car écrasé et ajouté la fonction
sum()
de la classe
IntArray
et c'est tout.
Pour la construction, on l'écrit avant la fonction principale. Comme ceci :
fun somme_fn(tableau: IntArray): Int {
var somme: Int = 0
for (element in tableau) {
somme += element
}
return somme
}
fun main(){
val x: IntArray = intArrayOf(1, 2, 3)
var total: Int = somme_fn(x) // on appelle la fonction somme_fn(x)
//et on stocke le résultat dans la variable total
println("$total")
}
Cependant, la classe
IntArray
a une fonction interne qui donne le cumul des éléments avec
sum()
, donc tu peux avoir pareil comme ceci :
fun main(){
val x: IntArray = intArrayOf(1, 2, 3)
var total: Int = x.sum() // Appel de la fonction interne sum() de IntArray
println("$total")
}
fun main (){
val Tableau: IntArray = intArrayOf(1,2,3)
var Somme: Int = Tableau.sum()
print("$Somme")
}
Là, il fait juste l'addition des lignes 1, 2 et 3. Mais je ne vois pas le lien avec les editText (A3 à I3, dans mon cas) qui vont contenir les chiffres à additionner.
Pareil pour ça, comment je fais pour lui dire qu'il faut qu'il écrive dans les editText A3 à I3 ?
val Coche_pourcent = true
val Coche_gr = false
var Quantité_totale = 86.0
var Quantité_pourcent = 35.0
var Quantité_gr = 30.0
var Resultat_quantité = 12
fun main (){
if (Coche_pourcent == true) {
var resultat_pourcent = ((Quantité_pourcent*Quantité_totale)/100)
print ("$resultat_pourcent")} else {
print ("$Quantité_gr")
}
}
Salut,
De ce que j'ai compris, pour créer une application, on va écrire du xml pour la mise en forme des widgets.
Les widgets sont les différents éléments qui peuvent être visibles dans l'application pour l'utilisateur. Un bouton, une portion de texte, etc. sont des widgets.
Kotlin est un langage de programmation qui permet d'automatiser des tâches. Pour faire le lien entre XML et Kotlin, on utilise la classe R et l'identifiant xml du widget en question.
Imaginons que tu as créé un widget liste en xml avec l'identifiant :
id_liste
, et chaque ligne s'identifie comme
id_ligne_N
avec N l'indice de ligne commençant à 0.
Avec la classe R, on aurait quelque chose comme :
inscrire avec la classe R la valeur de l'élément X de la liste de Kotlin dans id_ligneX
Maintenant, tu arrives à un niveau que je n'ai pas atteint. Il me sera difficile de t'aider sans effort de ta part. Je n'hésiterai pas à me renseigner pour t'aider.
C'est en anglais, c'est beaucoup d'informations, mais, tu ne pourras pas éviter de lire les guides et tutos d'Android Studio : https://developer.android.com/studio Bon courage pour la suite, et lorsque je le pourrai je t'aiderai volontiers.
OK, merci pour ta patience. J'essai de chercher de mon côté aussi. J'ai commencé le lien avec les exercices en Java peut être que j'y trouverai aussi des réponses. En tout cas, c'est plus attrayant et surtout plus clair que ce que propose kotlinlang.
En faisant quelques recherches, j'ai trouvé des similitudes entre une application Android et la création d'un site web.
Pour créer une application Android, on peut utiliser XML ainsi qu'un langage de programmation comme Kotlin par exemple. J'ai fait le parallèle entre l'XML et l'HTML, et aussi, entre Kotlin et Javascript.
Dans un dossier que tu peux appeler
similitudes
tu sauvegardes les fichiers suivants :
1) un premier fichier avec uniquement du html. La page web est statique, on ne peut rien faire dans la liste. Tu nommes le fichier
listeSansJS.html
:
<!DOCTYPE html>
<html lang="fr-fr">
<head>
<!-- La ligne ci-dessous permet d'afficher correctement
les caractères accentués par exemple -->
<meta charset="UTF-8">
<!-- La ligne ci-dessous permet d'adapter
la page web à la largeur de l'écran -->
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Exemple sans Javascript</title>
</head>
<body>
<ul>
<li>Premier élement de la liste</li>
<li>Deuxième élement de la liste</li>
<li>Troisième élement de la liste</li>
<li>Dernier élement de la liste</li>
</ul>
</body>
</html>
2) Quasiment le même fichier, mais, avec des modifications pour permettre l'interaction grâce à Javascript. Tu nommes le fichier
listeAvecJS.html
:
<!DOCTYPE html>
<html lang="fr-fr">
<head>
<!-- La ligne ci-dessous permet d'afficher correctement
les caractères accentués par exemple -->
<meta charset="UTF-8">
<!-- La ligne ci-dessous permet d'adapter
la page web à la largeur de l'écran -->
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Exemple avec Javascript</title>
</head>
<body>
<ul>
<li id="element_0">Premier élement de la liste</li>
<li id="element_1">Deuxième élement de la liste</li>
<li id="element_2">Troisième élement de la liste</li>
<li id="element_3">Dernier élement de la liste</li>
</ul>
<!-- J'explique plus loin¹ ce que fait la ligne suivante -->
<script src="remplir.js"></script>
</body>
</html>
3) Enfin, le code en Javascript. Tu le nommes
remplir.js
¹ :
"use strict";
// Il est conseillé d'initialiser
// dès le début les variables à utiliser.
let elements = [];
let element_a_ajouter = "";
let debut_prompt = "Tu peux écrire quelque chose ici ("
let fin_prompt = "/4) : ";
let id_liste = "element_"
for (let i = 1; i < 5; i++) {
let total_prompt = debut_prompt + i + fin_prompt
element_a_ajouter = window.prompt(total_prompt);
elements.push(element_a_ajouter);
}
for (let i = 0; i < 4; i++) {
let id_total = id_liste + i;
document.getElementById(id_total).innerHTML = elements[i];
}
Avec ton navigateur web, tu ouvres le fichier
listeSansJS.html
puis le fichier
listeAvecJS.html
et tu constates.
¹ la ligne
<script src="remplir.js"></script>
se situe à la fin de la balise
body
pour minimiser le risque de lenteur à l'ouverture de la page web car un script Javascript peut être lent. Cette ligne va tout simplement récupérer le code Javascript à l'endroit où il se trouve avec l'attribut
Si j'ai bien compris ce que j'ai fait hier, la fonction boucle (ou loop) est utilisée. Tu crois que je devais repenser ma formule pour qu'elle fasse une boucle à chaque editText à remplir (A3 à I3) ? Dans ce cas je pourrais abandonner l'idée les radioButton qui complexifient la formule pour pas grand chose d'utile.
J'ai créer une nouvelle activité qui s'ouvre lorsque j'appuis sur un imageButton cela fonctionne mais j'avoue que je ne sais pas si ma méthode est très académique :
fun inventory(view: View) {
val inventory = Intent(this, Inventaire::class.java).also {
startActivity(it)
}
}
Tu n'es pas obligée d'utiliser de boucle. Si je me souviens de l'interface graphique que tu as présentée, je vois un tableau avec des lignes à remplir. Pour chaque colonne, et si le nombre de lignes est fixe. Tu peux créer une liste. Et comme derrière chaque interface graphique il y a un gestionnaire d'événements, l'affichage se met à jour selon les événements.
En faisant comme cela, on n'est pas contraint à parcourir toute la liste pour une seule modification.
Pour la technique je ne sais pas. Je peux t'aider pour la méthode.
Tout d'abord, je créerais les patrons des activités du début à la fin de l'application. Quand l'appli se lance, est-ce que le tableau est pré-rempli ou vide ? Je ne pense pas à la programmation. Une fois fait, je cherche les liens possibles entre les activités, ces liens sont à coder avec un langage de programmation.
Quand l'appli ce lance l'appli est vide. Mais je me pose un question, ce que je cherche à faire existe déjà pour fonctionner sous Windows. La licence est gratuite : http://aromya.blogspot.com/2013/05/petit-programme-de-calcul-des-recettes.html?m=1
Est ce qu'il n'y a pas un moyen de voir "l'envers du décor" ?
En fait, tu l'auras compris j'ai un loisir pour lequel il y a un vide sous Android et je trouve ça dommage car cela serait très utile. Mais je me rends compte qu'il me manque énormément de connaissances pour parvenir à faire fonctionner cette appli.
Je suis étonné qu'il n'existe pas une telle appli sur Android. Vu ton assiduité, tu as quand même envie d'apprendre je pense. Et c'est une bonne chose, sans pour autant en faire son métier, mais, au moins, ça permet de mieux comprendre les coulisses de la création de logiciel et en plus on développe sa logique qui peut être utile pour des domaines autres qu'informatique.
Le cœur de l'appli que tu veux faire n'est pas compliqué, tu as déjà fait 80 % du boulot en Kotlin, les 20 % c'est du fignolage pas forcément indispensable. Il ne te manque plus qu'à trouver comment relier le calcul à l'interface graphique.
Si tu finis ton appli et que tu es satisfaite de ton travail et que tu souhaites te (ré)orienter dans un métier de développeuse. Je pense que la grosse plus-value est d'apprendre à programmer en multithreading et en asynchrone. Ce sont 2 types de programmation très compliqués mais optimaux pour les processeurs qui ont de plus en plus de cœurs et threads que ce soit pour les PC ou les smartphones et tablettes.
Pour te dire je suis dans un groupe Facebook qui compte pas moins de 75000 personnes, on échanges pas mal d'info, d'idées, de bon plan... mais rien sur le sujet d'une appli mobile. Juste des gens qui demandent si ça existe mais ils n'ont pas de réponses...
Je me demande si la réponse à ma question concernant le lien avec les editText ne ce trouve pas ici, mais je ne comprends pas le codage qui y est fait :
public void onRadioButtonClicked(View view) {
// Is the button now checked?
boolean checked = ((RadioButton) view).isChecked();
// Check which radio button was clicked
switch(view.getId()) {
case R.id.radio_pirates:
if (checked)
// Pirates are the best
break;
case R.id.radio_ninjas:
if (checked)
// Ninjas rule
break;
}
}
J'ai donc créé un nouveau projet plus simple que ce que je voulais faire en java pour tester :
s'ouvre bien ligne 27 mais se ferme avec l'accolade fermante de la ligne 72.
Retape ton code. Quand tu ouvres un symbole ouvrant et fermant, ferme de suite le symbole et écris le code entre. Dans le lien, à my code, l'accolade fermante de la fonction
You might see an error because Android Studio cannot resolve the View class used as the method argument. To clear the error, click the View declaration, place your cursor on it, and then press Alt+Enter, or Option+Enter on a Mac, to perform a Quick Fix. If a menu appears, select Import class.
Je viens de comprendre. Il faudrait que tu vérifies le fil conducteur de l’application. Soit en utilisant un débogueur (debugger), soit en plaçant judicieusement des
Le debugger ou les print peuvent servir lorsqu’il n’y a pas de message d’erreur.
Tu as une erreur sémantique quand l’ordinateur ne la relève pas.
Exemple simple, quand la quantité du produit est supérieure à 1, tu veux l’écrire au pluriel. Tu crées une fonction pour ça qui ajoute un s à la fin du mot. Pour bateau, le programme l’écrira bateaus. C’est une erreur d’orthographe mais pour l’ordinateur c’est normal. C’est une erreur sémantique.
J'ai passé l'appli au debugger, et ce qui me viens à l'esprit c'est "What ?!", pas de message d'erreur jusqu'à ce que je selectionne le radioButton gr., que j'indique une quantité et je clic sur le bouton Calcul (en E/) :
J'ai envelvé la condition que j'avais mis au dessus.
12/30 18:42:02: Launching 'MainActivity' on Pixel 3a API 29.
Install successfully finished in 2 s 868 ms.
$ adb shell am start -n "com.example.trainning/com.example.trainning.MainActivity" -a android.intent.action.MAIN -c android.intent.category.LAUNCHER -D
Waiting for application to come online: com.example.trainning.test | com.example.trainning
Waiting for application to come online: com.example.trainning.test | com.example.trainning
Connected to process 18115 on device 'Pixel_3a_API_29 [emulator-5554]'.
Capturing and displaying logcat messages from application. This behavior can be disabled in the "Logcat output" section of the "Debugger" settings page.
W/ActivityThread: Application com.example.trainning is waiting for the debugger on port 8100...
I/System.out: Sending WAIT chunk
Waiting for application to come online: com.example.trainning.test | com.example.trainning
Connecting to com.example.trainning
Connected to the target VM, address: 'localhost:63419', transport: 'socket'
Capturing and displaying logcat messages from application. This behavior can be disabled in the "Logcat output" section of the "Debugger" settings page.
I/ample.trainnin: Not late-enabling -Xcheck:jni (already on)
E/ample.trainnin: Unknown bits set in runtime_flags: 0x8000
W/ample.trainnin: Unexpected CPU variant for X86 using defaults: x86
W/ActivityThread: Application com.example.trainning is waiting for the debugger on port 8100...
I/System.out: Sending WAIT chunk
I/System.out: Debugger has connected
I/System.out: waiting for debugger to settle...
I/System.out: waiting for debugger to settle...
I/System.out: waiting for debugger to settle...
I/System.out: waiting for debugger to settle...
I/System.out: waiting for debugger to settle...
I/System.out: waiting for debugger to settle...
I/System.out: waiting for debugger to settle...
I/System.out: waiting for debugger to settle...
I/System.out: waiting for debugger to settle...
I/System.out: waiting for debugger to settle...
I/chatty: uid=10135(com.example.trainning) identical 2 lines
I/System.out: waiting for debugger to settle...
I/System.out: debugger has settled (1440)
D/libEGL: Emulator has host GPU support, qemu.gles is set to 1.
W/RenderThread: type=1400 audit(0.0:98): avc: denied { write } for name="property_service" dev="tmpfs" ino=6829 scontext=u:r:untrusted_app:s0:c135,c256,c512,c768 tcontext=u:object_r:property_socket:s0 tclass=sock_file permissive=0
W/libc: Unable to set property "qemu.gles" to "1": connection failed; errno=13 (Permission denied)
D/libEGL: loaded /vendor/lib/egl/libEGL_emulation.so
D/libEGL: loaded /vendor/lib/egl/libGLESv1_CM_emulation.so
D/libEGL: loaded /vendor/lib/egl/libGLESv2_emulation.so
W/ample.trainnin: Accessing hidden method Landroid/view/View;->computeFitSystemWindows(Landroid/graphics/Rect;Landroid/graphics/Rect;)Z (greylist, reflection, allowed)
W/ample.trainnin: Accessing hidden method Landroid/view/ViewGroup;->makeOptionalFitsSystemWindows()V (greylist, reflection, allowed)
D/HostConnection: HostConnection::get() New Host Connection established 0xd98b5850, tid 18152
D/HostConnection: HostComposition ext ANDROID_EMU_CHECKSUM_HELPER_v1 ANDROID_EMU_dma_v1 ANDROID_EMU_direct_mem ANDROID_EMU_host_composition_v1 ANDROID_EMU_host_composition_v2 ANDROID_EMU_vulkan ANDROID_EMU_deferred_vulkan_commands ANDROID_EMU_vulkan_null_optional_strings ANDROID_EMU_vulkan_create_resources_with_requirements ANDROID_EMU_YUV420_888_to_NV21 ANDROID_EMU_YUV_Cache ANDROID_EMU_async_unmap_buffer ANDROID_EMU_vulkan_free_memory_sync ANDROID_EMU_vulkan_shader_float16_int8 ANDROID_EMU_vulkan_async_queue_submit GL_OES_vertex_array_object GL_KHR_texture_compression_astc_ldr ANDROID_EMU_host_side_tracing ANDROID_EMU_gles_max_version_2
W/OpenGLRenderer: Failed to choose config with EGL_SWAP_BEHAVIOR_PRESERVED, retrying without...
D/eglCodecCommon: setVertexArrayObject: set vao to 0 (0) 0 0
D/EGL_emulation: eglCreateContext: 0xd98e7840: maj 2 min 0 rcv 2
D/EGL_emulation: eglMakeCurrent: 0xd98e7840: ver 2 0 (tinfo 0xd9885190)
W/Gralloc3: mapper 3.x is not supported
D/HostConnection: createUnique: call
D/HostConnection: HostConnection::get() New Host Connection established 0xd98b5940, tid 18152
D/HostConnection: HostComposition ext ANDROID_EMU_CHECKSUM_HELPER_v1 ANDROID_EMU_dma_v1 ANDROID_EMU_direct_mem ANDROID_EMU_host_composition_v1 ANDROID_EMU_host_composition_v2 ANDROID_EMU_vulkan ANDROID_EMU_deferred_vulkan_commands ANDROID_EMU_vulkan_null_optional_strings ANDROID_EMU_vulkan_create_resources_with_requirements ANDROID_EMU_YUV420_888_to_NV21 ANDROID_EMU_YUV_Cache ANDROID_EMU_async_unmap_buffer ANDROID_EMU_vulkan_free_memory_sync ANDROID_EMU_vulkan_shader_float16_int8 ANDROID_EMU_vulkan_async_queue_submit GL_OES_vertex_array_object GL_KHR_texture_compression_astc_ldr ANDROID_EMU_host_side_tracing ANDROID_EMU_gles_max_version_2
D/eglCodecCommon: allocate: Ask for block of size 0x1000
allocate: ioctl allocate returned offset 0x3ff6cb000 size 0x2000
I/ample.trainnin: NativeAlloc concurrent copying GC freed 734(63KB) AllocSpace objects, 0(0B) LOS objects, 49% free, 1704KB/3408KB, paused 14.706ms total 128.430ms
D/EGL_emulation: eglMakeCurrent: 0xd98e7840: ver 2 0 (tinfo 0xd9885190)
D/eglCodecCommon: setVertexArrayObject: set vao to 0 (0) 0 0
I/Choreographer: Skipped 40 frames! The application may be doing too much work on its main thread.
I/OpenGLRenderer: Davey! duration=711ms; Flags=0, IntendedVsync=30072494612551, Vsync=30073161279191, OldestInputEvent=9223372036854775807, NewestInputEvent=0, HandleInputStart=30073163386500, AnimationStart=30073163513700, PerformTraversalsStart=30073169110200, DrawStart=30073186614600, SyncQueued=30073190630900, SyncStart=30073191525600, IssueDrawCommandsStart=30073191644500, SwapBuffers=30073193304500, FrameCompleted=30073206982300, DequeueBufferDuration=319000, QueueBufferDuration=1121000,
I/AssistStructure: Flattened final assist data: 2844 bytes, containing 1 windows, 15 views
D/AndroidRuntime: Shutting down VM
E/AndroidRuntime: FATAL EXCEPTION: main
Process: com.example.trainning, PID: 18115
java.lang.NumberFormatException: For input string: ""
at java.lang.Integer.parseInt(Integer.java:627)
at java.lang.Integer.parseInt(Integer.java:650)
at com.example.trainning.MainActivity$2.onClick(MainActivity.java:65)
at android.view.View.performClick(View.java:7125)
at com.google.android.material.button.MaterialButton.performClick(MaterialButton.java:992)
at android.view.View.performClickInternal(View.java:7102)
at android.view.View.access$3500(View.java:801)
at android.view.View$PerformClick.run(View.java:27336)
at android.os.Handler.handleCallback(Handler.java:883)
at android.os.Handler.dispatchMessage(Handler.java:100)
at android.os.Looper.loop(Looper.java:214)
at android.app.ActivityThread.main(ActivityThread.java:7356)
at java.lang.reflect.Method.invoke(Native Method)
at com.android.internal.os.RuntimeInit$MethodAndArgsCaller.run(RuntimeInit.java:492)
at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:930)
I/Process: Sending signal. PID: 18115 SIG: 9
Disconnected from the target VM, address: 'localhost:63419', transport: 'socket'
Bien franchement, je ne pige pas ce que tu veux faire avec Android Studio. Tu veux faire quoi de ton PDF, qu'il s'affiche sur le smartphone ? L'imprimer ? Le transférer vers un autre appareil (smartphone, ordi, ...) ?
En fait, je voudrais que le pdf collect les info inscrits par l'utilisateur pour générer un pdf imprimable.
D'après les infos que j'ai pu trouvé on peut mettre en forme le pdf sur jaspersoft et après l'intégrer sur le projet android mais il faut importer une library.
Sauf que je n'arrive pas à trouver comment on doit faire pour importer la library et le projet que j'ai fait dans jaspersoft dans android studio.
En tout cas, tu as super bien progressé. Tu dis que ton programme fonctionne. Alors, des spécialistes Android trouveront sans doute des choses à redire, mais, le principal c'est que le programme fonctionne. Je te conseille vivement de commenter tes codes sources et de bien choisir le nom des variables et des fonctions que tu crées. Pour les commentaires, on commente le pourquoi et non le comment. Pense à faire une documentation aussi.
Oui c'est même sûr qu'il y a beaucoup mieux que ce que j'ai fait mais pour ça il faut connaître les différentes fonctions qui existent et surtout savoir les mettre en application. Il y a quelques semaine le langage Java m'étais totalement inconnu. J'ai essayé de commencer par kotlin mais il y a encore trop peut d'info sur le sujet.
Là je suis en train de revoir les différents id pour les uniformiser.
Quand j'aurai trouvé comment générer des pdf je vais sûrement partager mon appli (si je trouve comment on fait, lol).
Mouais, 3 min 30 juste pour que le gars de la vidéo lise le code qui se lit en 15 secondes. Les vidéos c'est pas super pour apprendre, c'est plus une perte de temps. Cherche plutôt de la doc écrite. La semaine qui arrive j'aurais davantage de temps pour t'aider ;)
Je n'ai pas regardé la vidéo entièrement. Le gars met le curseur de la souris à la première ligne du code, il suit le code avec le curseur pour arriver à la fin environ 3 min 30 plus tard. Il paraphrase, ça ne sert à rien, on sait lire.
La page est une référence, une documentation concernant la classe
GridView
. On lit tout au début, mais, on pioche surtout.
Comme on construit d'abord l'objet de la classe, en premier lieu, je lirais la partie Public constructors. Il ne faut pas hésiter à cliquer de lien en lien et surtout faire des essais avec un code simple en provoquant des erreurs.
Pour XML, les constantes, et les méthodes, on a toutes celles qui font parties de
En quelques minutes, c'est pas simple à expliquer. Mais, pars d'abord du constructeur, pioche ce dont tu as besoin. La programmation se prépare en amont. Tu as besoin d'une liste, tu vas chercher les classes de liste, mais, il y aura certaines de ces classes qui ne conviendront pas, tu ne les sélectionnes pas. Dans les classes utiles, tu n'auras pas forcément besoin de tout. Tu façonnes ton projet avec des briques indépendantes les unes des autres mais, qui, reliées entre elles vont être à la conception du programme.
. Parce que dans le futur j'espère pouvoir permettre l'ajout de lignes en cliquant sur un bouton. Mais ça c'est si un jour je comprends le système de listes et des tableaux...
Par contre, lorsque je lance l'appli sur un Pixel 4XL j'ai un espace vide sur la droite, saurais-tu comment je peux obliger les
EditText
de la deuxième colonne à s'étirer en fonction de la taille de l'écran du téléphone ?
Pour revenir sur iText pourquoi dis tu que tu aimes bien le paragraphe qui le concerne sur l'exemple ? Je parle de ce passage : "The smallest text unit is a "Chunk" which is a String with a pre-defined font. A "Phrase" combines several Chunks and allows to define line spacing. "Paragraph" is a subclass of "Phrase" and allows to define more layout attributes, e.g. margins. The class "Anchor" is a subclass of "Paragraph" and serves as the basis for hyperlinks in the generated PDF."
C'est juste que je trouve ce passage tellement fluide et simple à comprendre, et l'article m'a l'air bien présenté. Je sais pas quoi dire de plus.
Pour ton programme, s'il fonctionne et qu'il fait ce que tu souhaites, les seules améliorations que je vois sont cosmétiques, mais, ça, c'est toi qui le gères.
Il faut qu'on soit sur la même longueur d'onde. Pourquoi générer un PDF dans Android Studio ? Ça n'a pas de sens.
Un PDF c'est simplement un fichier lisible non-modifiable par défaut contrairement à un document Word par exemple.
Si ton objectif est d'avoir un PDF pour bien présenter ta liste d'ingrédients et leurs quantités, il te faut créer un patron ou un template en anglais qui sera une base et ton programme selon les ingrédients va remplir les champs du patron.
Donc, AS n'a rien à voir là dedans. Je trouve mon idée du template pas déconnante. Il faut aussi savoir prendre les mesures entre l'écran et la feuille, car le rendu n'est pas forcément le même. Et je ferais 2 apps, celle que tu fais pour le grammage, et une autre qui génère le PDF.
Et en faisant une autre activité tu crois que ça pourrait le faire aussi ? Genre tu clics sur le bouton et ça ouvre un aperçu de l'impression.
En fait, le template c'est ce que j'ai cherché à faire avec jaspersoft mais je n'arrive pas a lier les 2 projets (android studio et jaspersoft studio).
Le problème est que les editText s'affichent l'un au dessous de l'autre alors que je voudrais qu'ils soient l'un a côté de l'autre. A quel android cela cloche t il ?
Est ce que tu saurais par hasard comment il faut faire pour sauvegarder le contenu d'un editText dans un editText (jusqu'à modification par un utilisateur) ?
La RAM sert à stocker les variables du programme tant que ce dernier est ouvert. Si tu acceptes de perdre le contenu de l'editText, alors, tu peux le stocker dans une variable supplémentaire.
Si, au contraire, tu veux conserver le contenu après avoir quitté le programme, tu devras la stocker dans la mémoire morte du smartphone. Dans ce cas je pense que tu peux créer un dossier spécial dans le dossier du programme pour y stocker le contenu.
Dans le deuxième cas, pour Kotlin ou Java la méthode est la même qu'avec d'autre langage. Attention, c'est beaucoup plus lent car la donnée fait la navette entre la RAM et la mémoire morte qui est très lente.
Donc, dans ce cas, je ferais la sauvegarde dans la mémoire morte quand l'utilisateur quitte l'appli. Visuellement, il ne verra rien, mais, en tâche de fond, l'appli restera ouverte mais invisible. Pour cette étape :
Tu ouvres en écriture binaire le fichier spécial ; Tu écris la valeur du contenu dedans ; Tu fermes (surtout n'oublie pas c'est méga important !) le fichier;
Pour le redémarrage de l'appli :
Tu ouvres le même fichier en lecture binaire Tu récupères (= lis) la valeur du contenu dedans ; Tu places ce contenu dans une variable ; Tu fermes le fichier;
J'ai fait ça mais ça bug, (problème sur la ligne 193, chez moi) qui correspond à la ligne 15 ici :
T'as une idée de ce qui cloche ?
Le debugger dit ça :
- Process: com.homemade.cosmethomev4, PID: 4610
java.lang.RuntimeException: Unable to start activity ComponentInfo{com.homemade.cosmethomev4/com.homemade.cosmethomev4.Inventory}: java.lang.NullPointerException: Attempt to invoke virtual method 'void android.widget.EditText.setText(java.lang.CharSequence)' on a null object reference
- Caused by: java.lang.NullPointerException: Attempt to invoke virtual method 'void android.widget.EditText.setText(java.lang.CharSequence)' on a null object reference
at com.homemade.cosmethomev4.Inventory.onCreate(Inventory.java:193)
Caused by: java.lang.NullPointerException: Attempt to invoke virtual method 'android.text.Editable android.widget.EditText.getText()' on a null object reference
at com.homemade.cosmethomev4.Inventory.Save(Inventory.java:209)
- Messages postés
-
14934
- Date d'inscription
- lundi 11 juillet 2005
- Statut
- Modérateur
- Dernière intervention
- 15 janvier 2021
3 011 > Adeline_ccmça donnerait un truc comme ça, non ?
Ceci, à mettre dans le du bouton.
Désolé, je ne vais pas être plus précis pour plusieurs raisons :
- je te conseille de renommer tes composants graphiques, tu vas te perdre avec les edit1, edit 2, edit 12, etc.
- je t'ai donné le squelette, le reste tu pourras le trouver par toi-même
- Messages postés
-
52
- Date d'inscription
- dimanche 6 décembre 2020
- Statut
- Membre
- Dernière intervention
- 17 janvier 2021
> BunoCS- Messages postés
-
14934
- Date d'inscription
- lundi 11 juillet 2005
- Statut
- Modérateur
- Dernière intervention
- 15 janvier 2021
3 011 > Adeline_ccmet la doc Android : https://developer.android.com/docs
- Messages postés
-
52
- Date d'inscription
- dimanche 6 décembre 2020
- Statut
- Membre
- Dernière intervention
- 17 janvier 2021
> BunoCS