Ce cours initie aux bases de la programmation en utilisant le langage Java : variables, boucles, fonctions, ... Il ne présuppose pas de connaissance préalable. Les aspects plus avancés (programmation orientée objet) sont donnés dans un cours suivant, «Introduction à la programmation orientée objet (en Java)». Il s'appuie sur de nombreux éléments pédagogiques : vidéos sous-titrées, quizz dans et hors vidéos, exercices, devoirs notés automatiquement, notes de cours.
Boucles
Loading...
Del curso dictado por École Polytechnique Fédérale de Lausanne
Initiation à la programmation (en Java)
182 calificaciones
De la lección
Structures de contrôle (2) : boucles et itérations
Cette semaine, nous terminons la présentation des « structures de contrôle » avec les boucles et les itérations qui permettent de faire répéter certaines parties d'un programme.
Conoce a los instructores
Jean-Cédric ChappelierDr.
School of Computer and Communication Sciences
Jamila SamDr
School of Computer and Communication Sciences
In previous episodes we have discussed
the notion of control structures. We have seen that
they are particular instructions,
making it possible to execute processing
on the basis of conditions. Also, they allow to repeat processing.
Today, we will dig deeper in this topic and tackle
another way to repeat processing : the conditional loops.
If, in a program,
we wish to repeat a processing sequence
and that the number of repetitions is known a priori, namely
before entering the loop, we have seen
that it was possible to resort to "for loops", via the concept of iteration.
However, in certains situations, we do not
a priori how many times we wish to repeat the processing.
Typically, we could want
to repeat a processing as long as a condition is verified
without knowing how many
repetitions will be necessarily required before
the condition becomes false.
In such a case, we need to resort to another control structure:
the conditional loops.
They are repetitions which will
depend on a condition. In Java, they take the form
of "while" loops or "do while" loops.
Those are the subject of today's episode.
To help you get an idea, we will go back to our example
regarding the average of a certain number of grades.
We do not know à priori how many
grades we will have to calculate the average of.
Thus, we start by asking the user to fill us up through keyboard interation.
Once the number of grades has been entered, if this number
is strictly positive, we will initiate a
repetitive process, a "for loop" permitting
the input of all these grades,
still via keyboard interaction. We will
add the newly typed grade to the sum and calculate the average later.
Once the number of grades has been reached,
once all grades have been entered, we will
exit the "for loop", calculate and print the average of the grades.
Upon closer inspection, we may find it
unnatural to let the user input a number of grades equal to 0.
Indeed, it doesn't make much sense.
Thus, we are wondering
how to compel the user to
input a number of grades greater
than 0.
The underlying idea is to repeat these processing until
the user inputs a number
of grades strictly positive.
The solution to repeat these two lines of instruction
as long as the user has not entered a number of
grades strictly positive, is to resort
to a particular instruction : a "do while" conditional loop.
So, how do
we write such a control structure ?
We use the keyword "do", that is,
repeat. And the kekyword "while".
What do we wish to repeat ?
Actually, we wish to repeat the execution
of these two instructions,
which are in braces. We will repeat
these instructions as long as this condition is true.
So, if the user were to input a number of grades
less or equal to 0, the evaluation of this condition
will return "true". Therefore,
we will repeat these processing,
entering a new cycle of the loop.
Let us examine step by step
the execution of such a "do while" instruction.
First of all, we declare
a variable storing the to-be-entered number of grades.
Then, we execute directly
the instruction "do while".
Here, nothing special, we will
execute the so-called loop's body,
namely the instructions which will
be repeated if need be.
Here, we will ask the user to input the number
of grades. Let us imagine that they type the value 0.
We now reach this line,
where the continuation condition will be evaluated.
Here, since the number of grades is equal to 0, the condition will be evaluated
"true". We will thus
enter the loop again, repeating the processing.
We thus begin a new cycle of the loop.
We ask the user to type a number
of grades again. Let us imagine
that the user inputs this time, the value minus one.
We execute this instruction again, evaluating the
continuation condition. Again, since the number of grades
is less or equal to 0, the condition will be evaluated
as "true". Thus, we will repeat the processing once more.
At the third iteration, we will ask the user to input
another number of grades. This time, the crestfallen user
will understand what is expected of them
and input a strictly positive number.
Once we reach the instruction
evaluating the continuation condition.
This time, the evaluation will return
"false" since the number of grades
is strictly positive. Therefore, we will
stop iterating and exit the
"do while" loop.
Concretely, we will resume with the execution of these processing,
at the end of the "do while" loop, signified by this semicolon.
Thus, we will execute possible subsequent instructions
after the "do while" loop.
In this example, we clearly see that it is not possible
to forsee how many iterations will
be necessary before we can exit the loop.
Indeed, the number of repetitions is function
of the user's will, which we cannot guess à priori.
A "for loop" would thus not have been adapted to the
processing we attempt to achieve.
Now, let us examine thouroughly
the syntax of the "do while" instruction in Java.
We have here the keywords "do" and "while" framing the
so-called loop's body :
a block of instructions which we will repeat.
This block is in braces.
Following the keyword "while" is the
continuation condition. We will repeat the instructions
within the loop's body
as long as the condition is evaluated as "true".
In Java, similarly to the "if" instruction, the parentheses
around the condition are mandatory. Also,
the "do while" instruction is concluded with our
famous semicolon.
Similarly to the "if" instruction, the loop continuation condition
can be formulated in a rather sophisticated way,
for example through logical connectives.
We can imagine that we wish to repeat processing
as long as a variable x is equal to y plus z
and that z is not equal to 0 or that y is less than 3 and so on.
Thus, we see that we can formulate conditions
as complex as we wish thanks to logical connectives
An important remark regarding "do while"
loops is that the body will always be executed at least once.
Indeed, in our step by step example, we have seen
that when we execute the "do while" instruction
we enter the loop's body right away.
Therefore, we will execute the block of instructions
the first time we enter the loop.
From there, it will all depend on the evaluation of the condition.
The block of instructions will only be executed once if,
at the first iteration, the evaluation will return false.
In this case, we will indeed exit
the "do while" loop and resume
the processing thereafter. But, in the meantime, we will have
executed the block of instructions at least once.
This is a very important characteristic
of the "do while" conditional loop.
A last remark we can make
regarding "do while" loops
is that, if the condition is formulated in such a way
that it will not ever become "false", the loop will be repeated indefinitely.
Therefore, it is of the utmost importance to formulate
the condition so that we will exit the loop at some time.
The "do while" loop is a conditional loop where
the condition is evaluated a posteriori.
The loop's body will always be
executed once before we decide
if the processing will stop or be repeated.
In certains situations, it is necessary
to test the continuation condition
a priori before executing the loop's body a single time.
In such a case, we resort to another form of
conditional loops, the "while" loop which we will discuss now.
If we wish to write a "while" loop in Java,
we use the following syntax :
the keyword "while", immediately followed by
the loop continuation condtion,
then, in braces, the loop's body, that is
the block of instructions which we wish to repeat.
The operating principle is similar to the "do while" loop's :
we repeat the processing as long
as this condition returns the value "true".
The difference between the "while" and "do while" loops is that,
in "while" loops, the continuation condition is evaluted
as soon we execute the "while" instruction.
If this condition is
evaluated as "false" from the get-go, we will never execute the block of instructions.
Now, let us illustrate with two basic examples, the critical
difference between "while" and "do while" loops.
We have here two very similar loops.
where the continuation condition depends,
in both cases, on a variable i, initialized
to the value 100.
Let us start by examining what happens in the "do while" loop.
When we execute this line,
nothing prevents us from entering right away the loop's body.
At this point, the message "bonjour" will be printed on the terminal.
Now we execute this line, where
the continuation condition will be evaluated.
Since i is 100, obviously,
this condition will be evaluated to "false".
We will exit the loop immediately
and resume with the possible instructions following the "do while" loop.
In the meantime, the message "bonjour"
will have been printed.
Similar situation, this time with the "while" loop.
When we are to execute this line, we will evaluate the
continuation condition right away. As before, it will evaluated to "false".
Please note that in both cases,
the continuation condition has been evaluated to "false".
Here, since the condition is "false" we won't even enter
the loop's body and instead continue the execution
after the loop's body.
Therefore,
in this case, the loop will not print anything.
You can see that despite having two very similar loops,
one will print "bonjour", while the other will not print anything.
The most frequent mistakes regarding conditional loops are
often related to the formulation of the continuation condition.
The continuation condition is poorly formulated
and we will, for example, never exit the loop or
exit the loop too early, never executing
the loop, which we wanted to do.
However, there is a frequent
syntactic mistake, which we will
describe now. It is easy to fall in this trap,
especially if you're unfamiliar with "while" and "do while" loops.
The mistake is as follows : let us imagine that, at the end,
of the "while" condition, we inadvertently add a semicolon.
This mistake is made easier to commit by the fact
that there is a semicolon at the end of
the "do while" condition. However,
this semicolon is there to conclude the whole "do while" instruction.
It really does not belong here,
since after the "while" condition, we expect
to find a body of instructions.
Here, we probably wished to put " ++i " within the body.
However, what will happen here
is this : when we execute the
"while" instruction, everything happens
as if we had a body containing but an empty instruction.
So, let us imagined that we have previously initialized
our variable i to a value less than 10,
for example 1. Since here, the " ++1 "
is outside, nothing inside the loop's body
will have i evolve
so that it reaches a value which will make us
exit the loop. Therefore, the problem is that we will cycle
indefinitely within the loop, which is an errie
result to obtain, especially for beginners.
Thus, be wary of these little details
so that you do not fall in this trap while you are still inexperienced
with programming "while" and "do while" loops.
Now, you know several ways to carry out repetitive processing.
the "for loop", the "while" loop and the "do while" loop.
Now, you may wonder how to
choose between these different forms.
Actually, the choice depends on relatively
simple factors. Let us detail.
As we have seen in this sequence's introduction,
if we do know the number of iterations, we will naturally
choose a "for" loop.
Let us imagine for example, that we wish to calculate the average
of the grades of all this course's students.
The number of students attending to this courses is
known a priori and is also the
the number of iterations. Therefore, we will
choose a "for loop".
If we do know the number of iterations, we will have to resort
to a conditional loop,
either "while" or "do while".
Then, if the instructions are to be repeated at least once,
as we have seen a few minutes ago,
we will typically use a "do while" loop.
In what situations does this happen ?
A very typical example is the
regarding interaction with the user;
we need to ask a value to the user
and this value is limited by some criteria.
Therefore, we need to let the user input
at least one value before
we can test if the criteria are respected,
whether or not the condition is fulfilled.
In such a case, we will naturally
use a "do while" loop.
In all other cases, where we execute
the processing only if the condition
is verified, we will use
a "while" loop, the condition being evaluated a priori.
Let us examine now how to enrich
our introductory example by adding a few more functionalities.
For example, if the user inputs a number negative
or null we would like to display a message
signifying that it is not what the program is expecting.
For example, if the user inputs minus 2, we would like
to print "please type a number greater than 0".
This would avoid the stubbornness we have encountered earlier,
where the user would keep on entering undesired values.
So, how do proceed from them ?
Very clearly, this message will be
printed as many times as the user types
an undesired number, which could potentially be every time the user inputs a value.
It is quite natural to think we should write
these instructions, tasked with the printing of the message,
inside the body of a loop.
Therefore, we will proceed like this : we will
enrich the loop's body with new instructions.
So, once the user has entered the number of grades,
we will test if this number of grades matches with
the desired criteria. If such is not the case,
we will print a message destined to the user.
One of the tricks beginners encounter with "while" and "do while" loops
is the formulation of an adequate continuation condition.
Let us examine how to proceed thanks to a few examples.
Still in our example regarding the input of a number of grades,
we compelled the user to submitting a
number greater than 0. Now, we also wish that
this number does not exceed 10 grades.
Therefore, we do not want the user to input a number greater than 10.
So, how do we come up with this new condition ?
To formulate this condition,
the easier is probably to do so in plain words.
What do we want exactly ?
We want to repeat the processing
asking the user to input a number of grades
as long as this number is incorrect.
When is this number incorrect here ?
It can be in two situations.
Either the user has entered a number which does not satisfy
this first criteria or he has entered a
number of grades which does not fulfill this second criteria.
So, we find ourselves in a situation where the submitted number of grades
is incorrect if the user inputs something less or equal
to 0, or if they input something greater than 10.
This can be translated in Java pretty easily.
So, let us take back our first sentence :
"if it is less or equal to 0". This is exactly what we are
formulating here. OR - we can see the "OR",here -
if it is greater than 10, which we are formulating here.
We see here that the transition
of a formulation in plain words to Java can be done
in a very natural way, once we have in mind what we wish to test exactly.
In a similar spirit, let us imagine
that we wish to write a brief program
whose purpose is to have the user guess an unknown number.
To make things easier, we will
assume that they have to guess the numer 5.
The idea is to repeat the submission as long as
the user has not guessed the correct number.
So how do we formulate the condition ?
As we have done in the previous example,
we will start by formulating it in plain words.
The loop will be repeated as long as
the user has not guessed the secret number.
Concretely, as long as the entered number if different from the secret number.
Let us translate this formulation into Java.
As long as the entered number
if different from the secret number, is translated like this in Java.
Yet another example where the transition from plain words
into Java is very natural.
Now, let us enrich this here example and imagine
that we still wish to have the user guess a number but that
we are only granting them a limited number of trials. If they have not guessed
correctly after so many trials we stop and inform
them of their failure.
So, how do we modify the condtion so that the the loop
stops after, for example, three unsuccessfull trials
How do we formulate this condition ?
The idea here, is to resort to a trial counter.
We will count the number of trials; this counter
will be incremented at every iteration of the loop.
Now, let us formulate the condition so that depends on this counter.
We will keep our method and start by formulating it
in plain words : we want to repeat the
processing as long as the user has not guessed
the secret number and as long as he still has trials.
So, let us refine the description;
what does this condition exactly mean ?
We iterate, repeat the processing,
as long the inputted number if differrent from the secret number
and as long as the trial counter is less than 3.
So, now we are to translate this into Java.
The transcription here is still as natural.
The first condition : as long as the entered number is different
from the secret number will be written like that, simply.
The "and" is translated like this. And the second condition
will be written like this in Java.
Our user has now
two possible ways to exit the loop :
they can exit the loop because they have
guessed the correct number, that is the inputted number
has the same value as the secret number.
In this case, the evaluation of this part of the condition will return "false".
Since the global expression involves an "and", only one argument
of the "and" needs to be bo false so that the global expression
returns "false". In this case, we will exit the loop.
Other possible exit condition:
the user used has a number of trials
greater than or equal to 3.
Now, we would like to enrich our program a little bit more.
We wish to inform the user of the reason why they have exited the loop.
Did they exit because they have guessed the number, in which case
we want to inform him of his success, or did he exit in failure ?
Failure meaning they have not guessed the number before running out of trials.
The trick is that
it is only once we have exited
the loop that we can know why we exited.
Therefore, we place the instruction testing why we exited the loop
at the end of the "do while" loop.
So here, we will simply test
if we exited the loop having guessed
the secret number. In this case,
we inform the user that they have won.
In the other case, we will simply tell them that they have lost.
Please note that we evaluate the condition
"did we or not guess the correct number ?"
at two different places in the program.
Once in the "if", and another in the "while".
It would have been smart, for good practice, to regroup
these two condtions in a single variable. For example, here we could declare
a boolean variable, initialized to "false" inside the loop.
Then we store inside this variable, the value "entered number = secret number",
Now, we can replace this condition
here using our new variable.
As long as the secret number has not
been guessed and that the trial counter is less than 3, we will keep looping.
Similarly, we could replace this condition
by the evaluation "if (trouve)" (TN : trouve means, found or guessed)
Therefore, we have linked two identical
conditions while initially this link didn't exit : this is good practice.
Now, one needs to be careful while formulating these tests.
We can formulate them clumsily,
causing mistakes upon execution.
Here, for example, let us suppose that the user has guessed the correct number.
We're testing if they have not run of trials like this.
What will happen here, is that if the user has guessed the number
on his third trial, what was initially a success will be
interpreted as a failure. Indeed, this condition
will not be verified while the secret number
has actually been guessed on the third attempt.
Therefore, we will unfairly inform the user
that they have lost the game!
This should show how important
it is to think carefully while formulating the condition.
Formulating the condition in an explicit
way, as we did here previously, related to the secret number,
will make us dodge the trap
we have just analyzed in the previous example.
Explora nuestro catálogo
Inscríbete de manera gratuita y obtén recomendaciones personalizadas, actualizaciones y ofertas.
Coursera brinda acceso universal a la mejor educación del mundo, al asociarse con las mejores universidades y organizaciones, para ofrecer cursos en línea.
© 2018 Coursera Inc. Todos los derechos reservados.
