Explore
For Enterprise
Join for Free
Log In

艺术与人文
商务
计算机科学
数据科学
信息技术
健康
数学和逻辑
个人发展
物理科学与工程
社会科学
语言学习
學位
證書

瀏覽 Coursera 的全部課程

瀏覽
搜索
企業版
登錄
免費加入

Méthodes statiques

Loading...

Java面向对象编程入门

洛桑联邦理工学院

4.8（179 個評分） | 14K 名學生已註冊

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.

查看授課大綱

您將學習的技能

Interfaces, Logic Programming, Java Programming, Object-Oriented Programming (OOP)

審閱

4.8（179 個評分）

5 stars
145 ratings
4 stars
29 ratings
3 stars
5 ratings

MD

Oct 24, 2017

Cours excellent. Permet d'acquérir de solides bases.\n\nA conseiller à quiconque souhaite aborder le langage Java.

CC

Jul 19, 2017

Les bases importantes de l'orienté objet y sont bien expliquées et il y a une progression assez naturelle.

從本節課中

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.

Attributs statiques13:21

Méthodes statiques9:22

Interfaces16:38

Les interfaces depuis Java 822:05

教學方

Jamila Sam
Dr
Jean-Cédric Chappelier
Dr.

腳本

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.

探索我們的目錄

免費加入並獲得個性化推薦、更新和優惠。

Coursera 致力於普及全世界最好的教育，它與全球一流大學和機構合作提供在線課程。

© 2019 Coursera Inc. 保留所有權利。

通過 App Store 下載

通過 Google Play 獲取

Coursera
關於
管理團隊
工作機會
目錄
證書
MasterTrack™ 證書
學位
企業版
政府版

社區
Learners
Partners
Developers
Beta Testers
Translators

連接
博客
Facebook
領英
Twitter
Instagram
YouTube
技術博客

更多
條款
隱私
幫助
內容訪問
媒體
聯繫我們
目錄
附屬公司