Ce cours introduit la programmation orientée objet (encapsulation, abstration, héritage, polymorphisme) en l'illustrant en langage Java. Il présuppose connues les bases de la programmation (variables, types, boucles, fonctions, ...). Il est conçu comme la suite du cours « Initiation à la programmation (en Java) ». Comme son prédécesseur, ce cours 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.
Méthodes statiques
Loading...
來自 École Polytechnique Fédérale de Lausanne 的課程
Introduction à la programmation orientée objet (en Java)
170 個評分
Explore Related Videos
At Coursera, you will find the best lectures in the world. Here are some of our personalized recommendations for you
École Polytechnique Fédérale de Lausanne
170 個評分
從本節課中
Le modificateur static ; Interfaces
Cette semaine nous abordons la notion importante d'interface qui va complémenter vos acquis sur l'orienté objet en Java. Nous étudions aussi le modificateur static.
與講師見面
Jamila SamDr
School of Computer and Communication Sciences
Jean-Cédric ChappelierDr.
School of Computer and Communication Sciences
After the static attributes, we'll learn about static methods,
class methods, in this video episode.
Like with the attributes,
if we add the keyword "static" in front of a method,
then that method becomes a class method;
that is, a method that we can call without any object,
without any concrete instance of the class.
So let's see an example:
here we have a class A in which a method is defined.
"methode1", which is a class method, a static method.
We also have a usual method,
an instance method, here, named "methode2".
In the use example of this class method,
we see here that we can absolutely call
"methode1", a class method,
without any instance of the class A.
The syntax is simply: "name of the class, dot ('.'), name of the static method,
name of the class method".
This is entirely possible, it will call "methode1"
and print the message « Méthode 1 ».
Of course, for a standard method, an instance method
that isn't declared with the "static" keyword,
we aren't allowed to use this syntax, it doesn't make any sense.
"methode2" must be related to some instance.
So here, to continue the example, we create an instance 'v' of the class A.
Of course, we cal call the class method
with the syntax "v.methode1". That's exactly the same
that writing "A.methode1". It's only an alternative form.
I recommend you to rather use
"the name of the class"."the name of the method", for class methods,
to show your intention and remind that it's a class method,
even if the instance method notation is possible.
It is in my opinion a bit more ambiguous,
and I find this one to be more clear.
And of course, as usual, we can call "methode2",
which is an instance method on the 'v' instance.
As a static method can be called without any instance, without any object,
such a method can't rely on
the existence of such an object,
and can therefore not use any instance variable nor call any instance method.
The "this" reference doesn't exist in such a method,
as we can't guarantee the existence of an object.
So such a method, a static method,
can only call other static methods,
and can only access class members, static attributes.
Let's illustrate this with an example. Here we have a class A
that contains a usual non- static attribute 'i',
and a class attribute, a static attribute 'j',
a usual non-static instance method "methode1",
and a static method, "methode2", which is a class method.
In the usual method, "methode1",
we try to access the 'i' attribute, which isn't problematic.
A method linked here to an instance can access
both the instance attributes
and the 'j' class-attribute.
We can access the two.
Of course, we're allowed to call "methode2",
which is a class method, in "methode1".
So everything is permitted in an instance method.
But in a class method,
we can only access the attributes and the class methods.
If we try doing the same thing than in "methode1",
and accessing the instance attribute 'i',
then we'll get a compilation error.
We aren't allowed to do this because we are in a class method.
We can't guarantee the existence of an attribute,
of an object, of the A class.
But we can access the static attribute 'j',
'j' is a class attribute, a static attribute.
We are allowed to do this.
We aren't allowed either in "methode2", static method,
to call a non-static method, "methode1",
so this would also generate a compilor error.
On the other hand, we can absolutely call static methods,
including themselves.
This call is syntactically correct, there's no problem with it.
So of course, here, as we've called the same method,
we should be careful and take precautions
so that it doesn't end up with an infinite recursion,
and protect this call with a break condition.
But that is bringing us a bit to far, we only wanted to show, here,
that we can call another static method
in a static method.
Of course, if we create an instance like this in a static method,
we can absolutely create an instance like this in a static method,
so of course we can here call
"methode1" on the 'v' instance of the A class.
Therefore, what are the uses of these static methods, these class methods?
Well precisely, to write methods that aren't attached
to particular instances of a class,
very general methods, typically tool methods.
We'll do toolbox classes like this,
which we won't create any instance of,
but of which we'll simply use the class methods.
For example, a mathematical toolbox
like this class, 'MathUtils',
in which we've defined a class constant,
in which we can also define a class method,
that is, typically, a tool function 'auCube',
which would compute the cube of its parameter.
Of course, the creation of an object of 'MathUtils' type
is totally artifical.
We don't need any object of 'MathUtils' type,
and we could directly call the PI constant of the 'MathUtils' class,
as, let me repeat it, PI is indeed a class-variable.
We could therefore also call, like this, 'MathUtils.auCube(3.4)',
as here again, 'auCube' is an instance-method.
We can therefore call it without the creation of any 'MathUtils' object,
directly with the name of the class.the name of the method
to compute the cube of 3.4.
This 'MathUtils' class is only used to
store utility methods and constants.
It isn't used to create any concrete objects.
In fact, that's exactly the case of the Math class.
And if you had to use the PI constant,
you'd use the one of the API, and in standard Java that is written Math.PI,
the Math class of the API, exactly like
our small pedagogic example with MathUtils.
Of course, you never do this yourself,
but you use the constants defined in the API.
So that's typically what static methods,
class methods, can be used for.
That being said, avoid abusing of the "static" keyword,
avoid proliferating this "static" keyword,
and keep it for very particular cases.
Typically, the three following cases.
We can use static with 'final' for an attribute,
that is, here, a class variable, to define constants.
That was the example with the Math.PI variable.
The second situation is to use static without 'final',
for an attribute. That's more rare,
and it's for sharing a common value at the class level,
value common to the class, but that could change.
This situation is more rare and you won't come upon it
in the context of this course.
Concerning the methods, finally,
we can define class methods, static methods,
when, as we've seen before, we have utility methods,
for which it is artificial to link to a particular object,
and which are therefore invokable without any object.
It's generally also very rare that you write them yourself,
but you'll typically use the ones provided by the API,
like for example the sqrt, square-root, method
of the Math class, provided by the Java API.
Another example of static method, that you've already practiced,
is the main method.
And we now understand why the auxiliary methods,
which we call functions in general procedural programmation,
so the auxiliary methods of main are static methods.
As main has indeed a fixed header,
it must be a method that is static in a class.
As it's a static method,
it can only access other static methods,
and therefore the auxiliary methods of main
have to be static methods.
Likewise, the main method, because it is static,
can't access any object of the class in which it was defined.
So it can't access variables
and instance methods of the class in which it has been defined.
Note that apart from that,
the class in which the main method is defined
is like any other class, it can have attributes,
methods, constructors, etc.
Voilà! This concludes our episode about static methods,
class methods.
