Constructeur de copie

Loading...

來自 École Polytechnique Fédérale de Lausanne 的課程

Introduction à la programmation orientée objet (en Java)

169 個評分

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

Introduction à la programmation orientée objet (en Java)

169 個評分

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.

從本節課中

Constructeurs

Cette semaine aborde l'initialisation des objets (via ce qu'on appelle des « constructeurs »), ainsi que ce qui se passe lorsque l'on affiche, compare et affecte des objets en Java. La question de comment se passe la « fin de vie » des objets est aussi abordée.

Constructeurs (Introduction)8:35

Constructeurs par défaut en Java14:04

Constructeur de copie4:48

Fin de vie, affectation, affichage et comparaison d'objets17:40

與講師見面

Jamila Sam
Dr
School of Computer and Communication Sciences
Jean-Cédric Chappelier
Dr.
School of Computer and Communication Sciences

In today's episode,

we will focus on a particular constructor :

the copy constructor.

Thus, we will check what happens

when an object is initialized

with a copy of another object of the same class.

Indeed, Java lets us create instance copies

such as here, for example.

Here, we have a first "r1" instance of the "Rectangle" class

which we initialize through a call to a constructor

taking two values. This leads to the following schema.

"r1" is initialized to the values 12.3 and 24.5

Then, we have another "r2" instance of the "Rectangle" class.

r2 is initialized with a copy of r1.

We will thus copy r1's height into r2

and copy r1's width into r2.

However, r1 and r2 and two separated instances;

r2 has simply been initialized with a copy of r1.

The copy constructor is tasked with this kind of initializations.

The copy constructor is tasked with initializing an instance

with copy of another instance of the same class.

Its header is perfectly defined since it is a constructor.

It has thus the same name as the name of class.

And since it receives another instance of the same class,

its parameter list is reduced to one single parameter :

another instance of the same class.

For example, in the case our "Rectangle" class,

we would have a constructor, which is obviously in the interface

of the "Rectangle" class. This constructor is thus called "Rectangle".

Also, it receives, as its unique parameter, another rectangle,

another instance of the "Rectangle" class.

This instance would, for example,

be the copy of the height

of the rectangle received as parameter into the height of

of the instance we are currently initializing.

And similarly, a copy of the other rectangle's width into the width

of the instance we are currently initializing.

Let us go back to the previous example where we had an r1 rectangle

with a height of 12.3 and a width of 24.5

and an r2 rectangle

initialized with the copy constructor.

In this line we indeed have a call to the copy constructor.

Here, the construction of r2

will trigger a call to the copy constructor

passing, as parameter, r1

which is here "autre rectangle" (TN: means "other rectangle").

In this case, it is indeed r1

passed to the copy constructor of r2.

What happens is that, here, the height of r2

will receive the height of r1 in copy.

Through this line, we will copy

the height of r1 into the width of r2.

In the following line,

what happens is that we will

copy the width of r1 (the rectangle argument)

into the width of r2 (the rectangle we are currently constructing).

Here, we copy the width of r1 into the width of r2.

By the way please note that, unlike other languages,

Java does not provide us with a default version of the copy constructor.

This means that, if we do not do anything particular

we are not allowed to do copies, like these.

This constructor does not exist.

Therefore, if we want to do copy constructions,

we need to write it explicitly.

Also, the copy constructor is not the only way

to do copies in Java.

There is another way which is more widely used.

It is the "clone" method, as you can see here.

Through a call to the "clone" method, we will clone the r1 instance

which we had previously initialized with a usual constructor.

We will clone it into r2, upon the declaration-initalization

of the r2 instance of the "Rectangle" class.

This "clone" method will be detailed later in another video sequences

during the upcoming weeks.

This concludes this short episode on copy constructors in Java.

探索我們的目錄

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

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

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

通過 App Store 下載

通過 Google Play 獲取