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.
Fonctions : appel
Loading...
Del curso dictado por École Polytechnique Fédérale de Lausanne
Initiation à la programmation (en Java)
182 calificaciones
De la lección
Fonctions / Méthodes
Cette semaine aborde un sujet fondamental en programmation : les « fonctions » qui permettent de beaucoup mieux structurer les programmes et d'éviter d'avoir à récrire plusieurs fois la même portion de code.
Conoce a los instructores
Jean-Cédric ChappelierDr.
School of Computer and Communication Sciences
Jamila SamDr
School of Computer and Communication Sciences
In a previous episode, we introduced the notion of functions, of methods,
and their use in programming.
Today, we will focus on what happens
when we use, when we call a method.
Basically, at this stage, we know that the concept of a method is
associated to three aspects: the header, the definition and the call.
And today, we will look in detail into what happens
at the call.
Let's go back to our example on calculating means.
Here, we have a little main program which asks
the user to input two grades.
These two grades are input by the user via the keyboard,
and the mean of these two grades is displayed.
The calculation of the mean is done here by calling a method,
the "moyenne" method. [TN: "moyenne" means "mean"]
And we will now study the mechanisms involved in such a call.
Here, we have a real example of a method call, where the method called
is "moyenne", which we call by passing two arguments to it,
in the form of expressions which will of course correspond
respectively to the two parameters of the method.
Note that we usually name "parameters" the data which
the method needs to work as described in the header of the method,
and we name "arguments" the actual data passed to the method
at the moment it is called.
So the goal here is to examine what happens at the moment a call
like this is made.
The first step that is executed actually consists in evaluating
the different arguments and in Java, this evaluation will systematically be done
left-to-right.
So here, the first argument is evaluated.
The expression is evaluated, which will return a value of 2.3.
Second expression.
This will produce a value of 4.25.
Then, second step, a link will have to be established
between these arguments and the parameters of the method.
This is what happens during the second step.
So, during the second step, the parameter x will be matched with the result
of the first expression. x will be worth 2.3.
And y will be matched with the evaluation of the second
expression: 4.25.
We are thus in the situation where the parameters x and y have
actual values with which the method will now be able
to work and run.
Third step: the body of the method is executed.
Here, the body consists in a single instruction which is the return,
the return statement right here.
So here, the body doesn't actually execute anything in particular other
than the return statement.
Fourth step,
the expression which will serve as a return value will now
be evaluated.
So basically, (x+y)/2 will be calculated,
producing the following result.
And this value is now returned by the method to make it
available to the program that called it.
So actually,
this whole method call is replaced
by the result returned by the method.
So last step,
z takes a value of 3.275.
We have thus seen the five steps that usually occur
when we call a method.
First step: the expressions which are passed as arguments
to the method are evaluated.
Second, the values of these expressions are assigned to the parameters
of the method.
The method then has access to all the information that
it needs to work, and its body can be executed.
Fourth step: the expression which follows the first return statement encountered
during execution is evaluated and the result of the evaluation of this
expression is then returned as the result of the call.
These five steps occur in the most general case; there are situations
where the process is somewhat simplified.
We know that in the most general case a method needs
parameters, input data, and produces a result as output.
However, there are some situations where the method does not need any
input data. In such a case, of course, steps one and two,
which consist in evaluating the expressions passed as arguments and assigning
them to the parameters, no longer apply (for a method without arguments).
Then, there are situations where there is no output data, where the method
returns no result. And in this case, the steps which consist in
evaluating the expression following the return statement and returning this result,
i.e. steps 4 and 5, do not occur.
A method can easily call another method. This is the case in this
little example where you have a "afficheScore" (TN: means "displayScore") method which
takes as parameters a player, identified by an integer, a number of points won
by the player and the time he spent playing, and which will display
the player's score.
Here, it so happens that the score is calculated according to the number
of points and the time spent, and the calculation is done by a method.
The method is defined elsewhere
and takes as parameter the number of points and the game time.
You now know the different steps which are executed
when a method is called in a program, and you now can see
a little diagram which summarizes these various steps.
Here, we have a method "f" called by a method "g".
The match between the parameters of the method and the calling arguments
is done at the moment of the method call.
So here, when we call the method, the argument is copied into the parameter
of the method which uses this to fulfill its job.
In the most general case, the method calculated a return value
and this return value is transmitted to the calling method which will be able
to use it to carry out its instructions.
You will no doubt have noticed all along this episode that
there is a certain jargon, a terminology associated to a method call.
Let's now summarize this jargon.
You will have understood that when I speak of "calling a method", I mean
that I use the method; here, I am using the method f to calculate
a result that I then assign to a variable x.
When I speak of "passing a value" as argument to a method, I mean
that this value is simply copied into a parameter of the method.
And finally, when I say that a method "returns" the value of y, for example,
I mean that the expression of the function call will simply be
replaced by the returned value.
So if we take a real example now, suppose that we have a
method "f" whose last instruction is this one
Suppose that this method is called like so, and that at the moment
of the call, the value of y is 5. To say that the method
returns the value of y -- that is, 5 -- is the same as to say that we simply
replace this call by the return value, i.e. 5.
And so, I can equally say "cos(0) returns cosine of zero",
or "cos(0) returns 1", for 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.
