Chapitre 2 Généralités

Sommaire Chaînes de caractères Règles générales d’écriture Notion de variable Notion de caractère Notion de constante Types primitifs de Java Les opérateurs et les expressions La classe scanner Référence: Lewis & Loftus (Chapitre 2)

Objectifs Utilisation des chaînes de caractères, de la concaténation, des espaces Déclaration et utilisation des variables: exploration Java: types primitifs de données Expressions: syntaxe et traitement Types de conversion de données Programmes interactifs: Classe Scanner

Chaînes de caractères Une chaîne de caractères en Java est notée ainsi: ¨chaine de caractères¨ Il s’agit d’une succession de caractères Les constantes chaînes correspondent à des objets de type String (classe String) La classe String dispose d’un certain nombre de méthodes permettant de manipuler ce type d’objet (pour l’instant, nous allons voir juste le minimum ) Exemple : String Ch1 = ¨cours Inf1002¨;

Chaînes de caractères Pour afficher une chaîne de caractères sur la sortie standard on utilise la méthode print ou println La méthode print ne provoque pas de changement de ligne: System.out.print (¨exemple d’affichage:¨); La méthode println provoque un changement de ligne: System.out.println (¨mon premier programme Java¨);

Chaînes de caractères System.out.println (¨mon premier programme Java¨); System.out: correspond à l’objet auquel est destiné le message (plus précisément, system désigne une classe dans laquelle est défini l’objet statique out qui correspond à la sortie standard) Println: nom de la méthode ¨mon premier programme Java¨: argument de la méthode ou paramètre de la méthode

Chaînes de caractères (VOIR: EX2) //******************************************************************** // Countdown.java Author: Lewis/Loftus // // Demonstrates the difference between print and println. public class Countdown { //----------------------------------------------------------------- // Prints two lines of output representing a rocket countdown. public static void main(String[] args) System.out.print("Three... "); System.out.print("Two... "); System.out.print("One... "); System.out.print("Zero... "); System.out.println("Liftoff!"); // appears on first output line System.out.println("Houston, we have a problem."); }

Output Three... Two... One... Zero... Liftoff! Houston, we have a problem. //******************************************************************** // Countdown.java Author: Lewis/Loftus // // Demonstrates the difference between print and println. public class Countdown { //----------------------------------------------------------------- // Prints two lines of output representing a rocket countdown. public static void main(String[] args) System.out.print("Three... "); System.out.print("Two... "); System.out.print("One... "); System.out.print("Zero... "); System.out.println("Liftoff!"); // appears on first output line System.out.println("Houston, we have a problem."); } Copyright © 2017 Pearson Education, Inc.

Chaînes de caractères Concaténation de deux chaînes: l’opérateur + permet la concaténation de deux chaînes de caractères Le résultat est une chaîne de caractères String Ch1= ¨Java¨; String Ch2= ¨Software Solutions¨; String Ch3= Ch1 + Ch2; // Java Software Solutions

Chaînes de caractères System.out.println (¨mon premier programme Java dans le cadre du cours PRO1024 durant cette session¨); // erreur System.out.println (¨mon premier programme Java¨ + ¨dans le cadre du cours PRO1024¨); System.out.println (¨je suis le cours PRO1024¨ + 4 + ¨autres cours¨); La valeur numérique est considérée comme caractère (s) sachant que l’une des opérandes est une chaîne, le résultat est une chaine de caractères Le résultat de l’opérateur + dépend du type de données utilisé : addition deux nombres ou concaténation de chaines de caractères - polymorphisme

Output 24 and 45 concatenated: 2445 24 and 45 added: 69 VOIR: EX3 //******************************************************************** // Addition.java Author: Lewis/Loftus // // Demonstrates the difference between the addition and string // concatenation operators. public class Addition { //----------------------------------------------------------------- // Concatenates and adds two numbers and prints the results. public static void main(String[] args) System.out.println("24 and 45 concatenated: " + 24 + 45); System.out.println("24 and 45 added: " + (24 + 45)); } Copyright © 2017 Pearson Education, Inc.

Règles générales d’écritures Les identificateurs Les mots réservés Le format libre Les caractères spéciaux et les séparateurs Les commentaires Le code universel utilisé par Java- Unicode (bytecode)

Règles générales d’écriture: les identificateurs Un identificateur correspond à une succession de caractères permettant de désigner différentes entités manipulées au niveau d’un programme Java: variable, classe, méthode, objet, etc. La suite de caractères que peut comporter un identificateur est formée de lettres (A-Z, a-z), de chiffres (0-9), du caractère de soulignement ‘_’ ou bien du caractère ‘$’ Le premier caractère d’un identificateur doit être une lettre, ou le caractère de soulignement ‘_’ ou bien le caractère ‘$’ Java fait la différence entre majuscule et minuscule

Règles générales d’écriture: les identificateurs Certaines règles sont utilisées dans le choix des identificateurs: Les noms de variables et celui des fonctions sont écrits en minuscules, sauf s’ils sont composés de plusieurs mots, dans ce cas chaque mot commence par une majuscule sauf pour le premier: nomClient Le nom des classes suit la même règle, sauf que la première lettre est une majuscule Les constantes sont entièrement écrites en majuscule

Règles générales d’écriture: les mots réservés Certains mots-clés sont réservés par le langage de programmation Java et ne peuvent être utilisés comme identificateurs Abstract Final Char Byte Int For, …

Règles générales d’écriture: les caractères spéciaux Une séquence d’échappement est une séquence de caractères représentant un caractère spécial Une séquence d’échappement commence par (\) Séquence d’échappement Signification \b espace \t tabulation \n nouvelle ligne \r retour chariot \¨ double quote \’ simple quote \\ barre oblique

VOIR: EX4 //******************************************************************** // Roses.java Author: Lewis/Loftus // // Demonstrates the use of escape sequences. public class Roses { //----------------------------------------------------------------- // Prints a poem (of sorts) on multiple lines. public static void main(String[] args) System.out.println("Roses are red,\n\tViolets are blue,\n" + "Sugar is sweet,\n\tBut I have \"commitment issues\",\n\t" + "So I'd rather just be friends\n\tAt this point in our " + "relationship."); } Copyright © 2017 Pearson Education, Inc.

Output Roses are red, Violets are blue, Sugar is sweet, But I have "commitment issues", So I'd rather just be friends At this point in our relationship. //******************************************************************** // Roses.java Author: Lewis/Loftus // // Demonstrates the use of escape sequences. public class Roses { //----------------------------------------------------------------- // Prints a poem (of sorts) on multiple lines. public static void main(String[] args) System.out.println("Roses are red,\n\tViolets are blue,\n" + "Sugar is sweet,\n\tBut I have \"commitment issues\",\n\t" + "So I'd rather just be friends\n\tAt this point in our " + "relationship."); } Copyright © 2017 Pearson Education, Inc.

Règles générales d’écriture: les caractères spéciaux Cette notation s’avère utile dans certains cas, notamment dans des chaînes de caractères: System.out.println(¨J’ai nommé cours ¨PRO1024¨ pour le moment¨) // erreur (confusion pour le compilateur) System.out.println(¨J’ai nommé cours \¨PRO1024\¨ pour le moment¨)

Règles générales d’écriture: les séparateurs Dans un programme Java des séparateurs sont utilisés pour séparer les identificateurs, les mots clés et les symboles Ces séparateurs sont le blanc, la tabulation et la fin de ligne Lorsqu’ils sont bien utilisés, ces séparateurs permettent une meilleure lisibilité et donc une meilleure compréhension du programme La lisibilité peut être également améliorée grâce à l’indentation (tabulations successives)

Règles générales d’écriture: les commentaires Les commentaires sont des textes explicatifs permettant une meilleure compréhension du programme Les commentaires peuvent apparaître à n’importe quel endroit du programme Il existe trois formes de commentaire: Première forme de commentaire – qu’on appelle également commentaire de fin de ligne. Cette forme est introduite par // et tout le texte qui suit jusqu’à la fin de la ligne est considéré comme commentaire. // ceci est un commentaire

Règles générales d’écriture: les commentaires Seconde forme de commentaire – c’est un commentaire s’étendant sur plusieurs lignes Ce commentaire est surtout utilisé dans des emplacements propices à la lisibilité /* ceci est une autre forme de commentaire qui s’étend sur plusieurs lignes */ Troisième forme de commentaire – appelé commentaire de documentation utilisée par des utilitaires tel que Javadoc /** ceci est la troisième forme de commentaire*/

Notion de variable Une variable est un nom qui sert à repérer un emplacement donné de la mémoire centrale Déclarer une variable correspond à spécifier le nom de la variable et le type d’information qu’elle contiendra int total, date, résultat; // déclaration de plusieurs variables de type entier int age; // déclaration d’une seule variable de type entier

Notion de variable Initialisation Une variable peut être initialisée à la déclaration ou ultérieurement // portion d’un programme int sum = 12; int add; … add = 14; int n; if (…) n = 30 p = 2*n; // erreur Une variable ne peut être utilisée sans être initialisée auparavant (faire attention, ceci s’applique seulement aux variables déclarées au niveau du main, cela ne concerne pas les champs des différentes classes qui sont soumis à une initialisation implicite) La valeur de la variable peut évoluer durant l’exécution du programme

VOIR: EX5 //******************************************************************** // PianoKeys.java Author: Lewis/Loftus // // Demonstrates the declaration, initialization, and use of an // integer variable. public class PianoKeys { //----------------------------------------------------------------- // Prints the number of keys on a piano. public static void main(String[] args) int keys = 88; System.out.println("A piano has " + keys + " keys."); } Copyright © 2017 Pearson Education, Inc.

Output A piano has 88 keys. //******************************************************************** // PianoKeys.java Author: Lewis/Loftus // // Demonstrates the declaration, initialization, and use of an // integer variable. public class PianoKeys { //----------------------------------------------------------------- // Prints the number of keys on a piano. public static void main(String[] args) int keys = 88; System.out.println("A piano has " + keys + " keys."); } Copyright © 2017 Pearson Education, Inc.

Notion de variable Opérateur d’affectation ‘=‘ l’opérateur d’affectation permet de changer la valeur d’une variable Ex: total = 25; // une première valeur total = 33; // la première valeur est remplacée par la valeur 33 Java est un langage fortement typé. A cet effet, il faut faire très attention quant à la compatibilité des types (Une variable de type entier doit se voir affectée une valeur entière. On verra cela un peu plus tard lorsqu’on parlera de conversion de types)

VOIR: EX6 //******************************************************************** // Geometry.java Author: Lewis/Loftus // // Demonstrates the use of an assignment statement to change the // value stored in a variable. public class Geometry { //----------------------------------------------------------------- // Prints the number of sides of several geometric shapes. public static void main(String[] args) int sides = 7; // declaration with initialization System.out.println("A heptagon has " + sides + " sides."); sides = 10; // assignment statement System.out.println("A decagon has " + sides + " sides."); sides = 12; System.out.println("A dodecagon has " + sides + " sides."); } Copyright © 2017 Pearson Education, Inc.

Output A heptagon has 7 sides. A decagon has 10 sides. A dodecagon has 12 sides. //******************************************************************** // Geometry.java Author: Lewis/Loftus // // Demonstrates the use of an assignment statement to change the // value stored in a variable. public class Geometry { //----------------------------------------------------------------- // Prints the number of sides of several geometric shapes. public static void main(String[] args) int sides = 7; // declaration with initialization System.out.println("A heptagon has " + sides + " sides."); sides = 10; // assignment statement System.out.println("A decagon has " + sides + " sides."); sides = 12; System.out.println("A dodecagon has " + sides + " sides."); } Copyright © 2017 Pearson Education, Inc.

Notion de constante Dans un programme Java, il est possible d’interdire la modification de la valeur d’une variable en la précédent par le mot clé final Toute tentative de modification de la variable sera rejetée (erreur de compilation) // portion d’un programme final N = 20; …. N = 12; // erreur

Notion de constante Les constantes sont très utiles dans un programme Une meilleure signification qu’une valeur – Max-charge au lieu de 250 Facilitent le processus de maintenance – la mise à jour nécessite une seule modification même si la constante est utilisée à différents endroits du programme Permet une meilleure compréhension en précisant que cette var ne doit pas changer ou évoluer durant l’exécution du programme

Types primitifs de Java Les types primitifs en Java se répartissent en 4 catégories: (selon la nature des informations qu’ils peuvent représenter) - Les types entiers: byte, short, int, long; - Les types flottants: float, double; // approximation des nombres réels - Le type caractère: char; - Le type booléen: Boolean; Tous ces types diffèrent par la taille de l’espace mémoire utilisé pour stocker une valeur de ce type (les valeurs diffèrent d’un type à l’autre) La taille de chacun de ces types est la même quelque soit la plateforme utilisée Tous les types numériques sont signés (valeur positive ou négative)

Types primitifs de Java Lors de l’écriture des programmes, il est impératif de choisir la taille appropriée (peu ou trop d’espace) Type byte short int long float double Storage 8 bits 16 bits 32 bits 64 bits Min Value -128 -32,768 -2,147,483,648 < -9 x 1018 +/- 3.4 x 1038 with 7 significant digits +/- 1.7 x 10308 with 15 significant digits Max Value 127 32,767 2,147,483,647 > 9 x 1018 Copyright © 2017 Pearson Education, Inc.

Types primitifs de Java Tous les types littéraux (byte, short, long) sont des entiers malgré certaines précisions du genre 423L ou 423l Tous les floats sont systématiquement convertis en double. Pour éviter cette conversion, on utilise la notation suivante: 42.5F ou 42.5f (on gagne en espace mais en perd en précision) Exemples: Int nombrejoueur= 12; Byte petit, grand; long distance= 34567892143l; float ratio=32.7f; Double surface= 3456.36789123;

Types primitifs de Java : Type caractère Comme tout autre langage, Java permet de manipuler des caractères en les représentant sur deux octets grâce à l’utilisation du code universel unicode (soit 65536 combinaisons – on retrouve ainsi les 128 possibilités du code ASCII (7bits) et les 256 possibilités du code ASCII\ANSI utilisé par windows) Un caractère est délimité ainsi: ‘a’ ‘b’ ‘x’ ‘7’ ‘\n’ Une variable caractère se déclare ainsi: char note= ’A’; char cote=‘C’, Ptvirgule=‘;’, blanc= ‘ ‘, chiffre=‘8’; Cette notation n’est possible que si le caractère est disponible dans l’implémentation considérée (dispose d’un graphisme et d’une combinaison de touches permettant de le saisir) Certains caractères ne possédant pas de graphisme disposent d’une notation conventionnelle utilisant le caractère ‘\’ comme la tabulation, le saut de ligne, le retour chariot, etc.

Notion de caractère Code unicode Une variable de type char permet de stocker un seul caractère contrairement au type String qui lui permet de stocker toute une chaine de caractères Code unicode La plupart des langages permettent d’écrire des programmes avec un nombre limité de caractères (caractères codé sur un seul octet) - variante du code ASCII international Dans Java, on a essayé d’atténuer (le fait de ne pas pouvoir représenter tous les caractères, par exemple ceux avec accents) cet handicap en utilisant le code unicode (basé sur 2 octets) permettant ainsi 65536 combinaisons pour représenter les différents symboles utilisés. On peut dire que le code ASCII est un sous ensemble de unicode

Types primitifs de Java : Type caractère Le code ASCII est un sous ensemble du code universel Unicode, incluant: uppercase letters lowercase letters punctuation digits special symbols control characters A, B, C, … a, b, c, … period, semi-colon, … 0, 1, 2, … &, |, \, … carriage return, tab, ... Copyright © 2017 Pearson Education, Inc.

Types primitifs de Java : Type booleen Ce type permet de représenter une valeur logique du type vrai/faux (tous les langages ne disposent pas de ce type, ils se contentent d’utiliser les instructions de sélection if) Autrement dit, seule les mots réservés true et false sont les valeurs valides de ce type Exemple: boolean etat = true; boolean ordonne; … …. ordonne = p<n; // ordonne reçoit la valeur de l’expression booléenne p<n

Les opérateurs et les expressions Dans la plupart des langages, y compris Java, on retrouve: - des opérateurs, - des expressions formées à l’aide d’opérateurs et d’opérandes, - des instructions pouvant utiliser des expressions – instruction d’affectation.

Les opérateurs et les expressions: les opérateurs arithmétiques Fonction opérateur Exemple Addition + a+b Soustraction - a-b Multiplication * a*b Division / a/b Modulo % a%b Exemple : 23%5=3, 39%5= 4 // le résultats est le reste de la division entière Lorsque plusieurs opérateurs apparaissent dans une même expression, il est nécessaire de connaître leur priorité (préséance) relative : 1. (), 2. *, /, %, 3. +, - On parle d’associativité de gauche vers la droite

Les opérateurs et les expressions: les opérateurs relationnels Fonction Opérateur Exemple Inférieur à < a < b Supérieur à > a > b Inférieur ou égal à <= a <= b Supérieur ou égal à >= a >= b Différent de != a != b Égal à == a == b  Les quatre premiers opérateurs possèdent la même priorité.  Les deux derniers possèdent, également, la même priorité mais inférieure à celle des précédents.  Les opérateurs relationnels sont moins prioritaires que les opérateurs arithmétiques.  Exemple : a+ b > c+g

Les opérateurs et les expressions: les opérateurs logiques Fonction Opérateur Exemple Non logique ! ! (a == b) Et logique && (a == b) && ( c > d) Ou logique || (a == b) || ( c > d)   Les opérateurs sont classés par priorité décroissante. L'opérateur ! à une priorité supérieure à tous les opérateurs arithmétiques binaire et opérateurs relationnels. Les deux opérateurs && et || ont une priorité inférieure aux opérateurs arithmétiques et relationnels. Exemple : ! a == b sera interprétée (!a) == b et non ! ( a == b) a < b && c < d sera interprétée (a< b) && ( c < d)

Les opérateurs et les expressions: les opérateurs d’affectation L’opérateur d’affection ‘=‘ consiste à manipuler une variable Son rôle consiste simplement à placer une certaine valeur L’instruction d’affectation détermine la valeur de l’expression située à droite de ‘=’ et range le résultat dans la variable située à gauche de ‘=’ Outre l’opérateur d’affection ‘=‘, Java dispose d’autres opérateurs d’affectation permettant ainsi de simplifier l’écriture 

Les opérateurs et les expressions: les opérateurs d’affectation Fonction Opérateur Exemple Addition + = F += 7  F = F + 7 Soustraction - = G -= 5  G = G – 5 Multiplication * = B *= C  B = B * C Division /= X /= Y  X = X / Y Modulo %= A %= B  A = A % B Tous ces opérateurs ont la même priorité Ils sont moins prioritaires que les opérateurs arithmétiques et les opérateurs relationnels et logiques.

Les opérateurs et les expressions: les opérateurs d’incrémentation et de décrémentation Dans un programme on rencontre les expressions suivantes:   i = i + 1; n = n – 1; Ce sont des instructions qui incrémentent ou décrémentent de 1 la valeur d’une variable. Java permet de réaliser ces actions par des opérateurs ‘unaires’ ++i  i = i + 1 --n  n = n - 1

Les opérateurs et les expressions: les opérateurs d’incrémentation et de décrémentation Fonction Opérateur Exemple Post-incrémentation ++ i++ Pré-incrémentation ++ ++i Post-décrémentation -- i-- Pré-décrémentation -- --i Dans une expression comportant un opérateur de pré-incrémentation (pré-décrémentation), l’incrémentation (décrémentation) se fait avant l’évaluation de l’expression.   L’incrémentation (décrémentation) se fait après l’évaluation de l’expression dans le cas contraire (post).

Les opérateurs et les expressions: opérateur conditionnel L’opérateur conditionnel est représenté par les symboles : ‘?’ et ‘:’ Exemple : max = a>b ? (a+1): (b*4) a>b , a, b sont les opérandes de l’expression L’opérateur évalue la condition (expression booléenne) si elle est vraie, on évalue le second opérande (a +1) sinon c’est l’opérande trois qui sera évalué (b*4) Autre exemple A>b ? ++i: i++ Z=(a>b ? a:b)

Conversion de données Dans certains cas, il est nécessaire de convertir une donnée d’un type donné en un autre (convertir une variable int en float) Cette conversion ne change pas le type de la variable ni la valeur stockée dans cette dernière. Elle ne concerne que l’expression dans laquelle apparaît cette variable (le calcul) En java, il existe 3 façons de convertir les données: - conversion d’ajustement et promotion numérique - conversion par affectation - conversion forcée – opérateur de cast

Conversion de données: Conversion d’ajustement de type - Une conversion telle que int en float est appelée conversion d’ajustement - Cette conversion se fait selon la hiérarchie suivante: int->long->float->double (1) - Cette conversion ne dénature pas la valeur initiale si est elle effectuée selon (1) - Convertir float en int est une erreur – non respect de (1) à moins de forcer la conversion (opérateur de cast) - La conversion d’ajustement à lieu dans une expression dont les opérandes sont de différents types Exemple: int compte; float somme, resultat; résultat = somme/ compte; // conversion de compte en float.

Conversion de données: Promotion numérique - Les conversions d’ajustement ne permettent pas de régler tous les cas, en particulier pour les types byte, short et char - Lorsqu’une valeur de l’un de ces types apparaît dans une expression, elle est automatiquement convertie en int Exemple: byte b; char c; int a; a = b+c; // b et c sont automatiquement convertis en int

Conversion de données: Conversion d’affectation Lors de l’affectation d’une valeur de type int à une variable de même type – le résultat est une valeur de type int Lors de l’affectation d’une valeur de type int à une variable de type float, il y a automatiquement une conversion d’ajustement de la valeur de type int en float (aucune dégradation) Cependant, cela pose problème dans le cas suivant : int n; float x; n = x +3; // erreur dégradation et non respect de (1) Les conversions implicites sont celles qui se font selon les deux schémas suivants: - byte->short->int->long->float->double - char->short->int->long->float->double

Conversion de données: Opérateur de cast Il est possible de forcer la conversion d’une expression quelconque vers un type particulier grâce à l’opérateur de cast Exemple: int n, p; l’expression double(n/p) aura une valeur de type double Int total = 50; float resultat = (float) total/6; // conversion de total en float float x = 3.2; int produit = (int) x*4; // conversion de x en int, perte de precision Il y a autant d’opérateurs de cast que de type primitifs Remarque: Java permet la conversion forcée dans un sens ou dans l’autre du byte short int … ou l’inverse

La classe Scanner Pour s’exécuter, un programme à souvent besoin de données en entrée Ces données peuvent provenir de différentes sources: fichier, clavier (souris ) La classe Scanner fournit différentes méthodes permettant la lecture de valeurs en entrée de différents types Le clavier est représenté par l’objet System.in Les séparateurs tels que blanc, tabulation, retour chariot sont utilisés pour séparer les différents éléments saisis en entrée. Pour permettre la lecture à partir d’un clavier on doit: - créer un objet Scanner : Scanner scan = new Scanner (System.in); - l’opérateur new permet la création d’un objet de type Scanner - grâce à cet objet, on peut utiliser différentes méthodes pour les données en entrée (définies dans la classe Scanner)

VOIR: EX7 //******************************************************************** // Echo.java Author: Lewis/Loftus // // Demonstrates the use of the nextLine method of the Scanner class // to read a string from the user. import java.util.Scanner; public class Echo { //----------------------------------------------------------------- // Reads a character string from the user and prints it. public static void main(String[] args) String message; Scanner scan = new Scanner(System.in); System.out.println("Enter a line of text:"); message = scan.nextLine(); System.out.println("You entered: \"" + message + "\""); } Copyright © 2017 Pearson Education, Inc.

Sample Run Enter a line of text: You want fries with that? You entered: "You want fries with that?" //******************************************************************** // Echo.java Author: Lewis/Loftus // // Demonstrates the use of the nextLine method of the Scanner class // to read a string from the user. import java.util.Scanner; public class Echo { //----------------------------------------------------------------- // Reads a character string from the user and prints it. public static void main(String[] args) String message; Scanner scan = new Scanner(System.in); System.out.println("Enter a line of text:"); message = scan.nextLine(); System.out.println("You entered: \"" + message + "\""); } Copyright © 2017 Pearson Education, Inc.

VOIR: EX8 //******************************************************************** // GasMileage.java Author: Lewis/Loftus // // Demonstrates the use of the Scanner class to read numeric data. import java.util.Scanner; public class GasMileage { //----------------------------------------------------------------- // Calculates fuel efficiency based on values entered by the // user. public static void main(String[] args) int miles; double gallons, mpg; Scanner scan = new Scanner(System.in); continue Copyright © 2017 Pearson Education, Inc.

System.out.print("Enter the number of miles: "); continue System.out.print("Enter the number of miles: "); miles = scan.nextInt(); System.out.print("Enter the gallons of fuel used: "); gallons = scan.nextDouble(); mpg = miles / gallons; System.out.println("Miles Per Gallon: " + mpg); } Copyright © 2017 Pearson Education, Inc.

Sample Run Enter the number of miles: 328 Enter the gallons of fuel used: 11.2 Miles Per Gallon: 29.28571428571429 continue System.out.print("Enter the number of miles: "); miles = scan.nextInt(); System.out.print("Enter the gallons of fuel used: "); gallons = scan.nextDouble(); mpg = miles / gallons; System.out.println("Miles Per Gallon: " + mpg); } Copyright © 2017 Pearson Education, Inc.