Variables

Loading...

En provenance du cours de École Polytechnique Fédérale de Lausanne

Initiation à la programmation (en Java)

182 notes

École Polytechnique Fédérale de Lausanne

Initiation à la programmation (en Java)

182 notes

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.

À partir de la leçon

Initiation à la programmation

Cette semaine vous accueille dans le cours et vous présente les premiers concepts de base de la programmation.

Introduction7:26

Variables : lecture/écriture21:35

Expressions12:52

Rencontrer les enseignants

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

In our introduction, we have discussed the different steps

leading to the creation of a program.

We know that we should start by thinking, conceptualizing,

and planning the sequence of instructions we aim to realize.

Then, we will translate this conception

into a known programming language, such as Java.

Then we will go through several steps,

of compilings, testings until we finally reach

the creation of program, executable on a computer.

Now, we will enter the heart of the matter

and acquire the tools necessary

to begin writling

little Java programs.

A program is simply

a sequence of instructions operating on data.

The notion of "sequence of instructions", is closely realted to the notion of processing.

Processing operate on data,

they can modify these data's values.

In turn, the data impact the processing,

since, depending on the nature of these data,

different processing will be performed.

Let us suppose, for example, that we wish to write

a brief program able

to solve a quadratic equation of this kind.

Let us think of the the adequate sequence of instructions.

The first step is probably

to ask the user to provide us with the coefficients b and c,

which will let us know concretely

what equation we're going to solve.

I now have the first data.

Starting with these data, we can perform other processing,

such as, for example, calculating the delta.

Then, depending on the value of this delta,

we will perform different processing.

For example, if delta is negative,

we will simply print that there is no solution.

Otherwise, we will treat the other cases.

For example, if delta is 0, we can calculate the unique solution

and print this solution.

Otherwise, we have the case with two solutions,

which we will not discuss here explicitly.

Here, we can clearly see that processing

impact data.

For example, here, the processing held

compute an arithmetic expression.

This processing indeed impacts the data,

for it will calculate a new data, which is delta.

The other way around, we can also see

that data impact processing.

Typically here, depending on delta's value,

we will perform different actions.

We can draw two important observations based on this example.

The first one is the notion of expression, which is fundamental

in order to start expressing processing.

The notion of expression will be a chapter

later in this course.

The second one is bound to the notion of data.

Here, the data "b² - 4c" is stored in a container, delta.

We need to associate this data to the name "delta"

since we use delta several times in the program.

We want to be able to find this data, whenever we need it.

The fact to associate a name to a data, delta to b² - 4c

is what we call in programming, the notion of variable.

This will be the topic of this episode.

The goal of this introductory course is to introduce the basic tools,

permitting to formulate basic processing

and to manipulate data in an adequate way.

We have seen, in the previous example,

how important the notion of expression was,

to which the notion of operator is related.

We will discuss operators later in this course, though.

Today, we will discover

the notion of variables, associated with the notion of data.

The notion of variable will let us

associate data with a name in a program.

You have here a small glimpse of the remaining fundamentals,

which will be studied during this introductory programming course.

In programming, a variable is a named memory area

usually called the identifier,

where we will store a value.

We can see this here.

A fundamental fact is that

variables must be associated with a type.

Java is a language demanding that we specify

the type of the data we wish to manipulate.

When we wish to use a variable,

a named area in the memory,

it will be necessary to specify its type,

what type of data we want to use.

For example, it may be necessary to use data

of the integer type, of the character string type.

Every time we wish to manipulate data

of a particular kind,

we will have to specify it through the type.

How should we proceed, in a Java program

if we wish to declare a variable,

namely to memorize a data through a variable ?

You have here, a little shell of a program

ready to welcome your instructions. Now, let us declare a variable.

First of all, we should decide the name of this variable;

if possible, this name should be eloquent, somehow describing the role of the variable.

Here, we will call this variable "nombre". (TN: nombre means number )

Now, we should come with an initial value, for example, 4.

And, of course, we should specify its type.

Here, I will precise that the number is an integer.

In Java, we write integer "int".

This line of code, we have just written in the editor

corresponds to what we call, the declaration of a variable.

In a program, we have to declare

that we wish to use a variable of a given type.

You have here two examples

of valid variable declarations in Java.

In the first case, we give an initial value

to the variable at the moment where we declare it.

In the second case, we simply declare a variable

without giving it an initial variable.

We can see here the fundamental

syntax elements we have introduced earlier.

The variable type must necessarily be specified

Same goes for its name, its identifier.

As we have seen, during its declaration,

a variable can be initialized,

namely, we can give it an initial value.

This corresponds to this situation in the memory.

It is good practice;

indeed, it is always desirable

for a variable to have a known value.

We have just seen that it was entierely possible, in Java,

for a variable to be declared without any initial value.

Here, we are declaring a variable

nCarré, of type int. (TN: nCarré means nSquared).

We are not giving it an initial value.

This corresponds to this situation in the memory.

We have here a variable nCarré, not storing anything known.

What we should know

is that Java does not permit, in a program,

to use a variable which has not been initialized.

For example, if, after having declared this variable nCarré,

We try to print its value

(we are anticipating on the next episodes,

regarding the printing of a value).

So, the printing of the variable nCarré

will be realized as follows.

If we try, right after the declaration of a variable,

to print its value,

we will obtain an error upon compiling.

The compiler will call us to order,

signifying that nCarré has not been initialized.

Therefore, we cannot use it.

However, this implies that, after declaring a variable,

without giving it a value,

we have the possibility to give it a value later in the program.

This is what we will discuss now,

introducing the assignment notion.

This will make it possible, after this instruction,

to modify, to store a value inside the variable nCarré

through the so-called assignment.

Regarding types, we already encountered,

in the previous examples,

the integer type, spelt "int" in Java.

Thus, if we wish to use a data corresponding to an integer

we will use the int type.

Naturally, there are other usable types.

For example, if we wish to use decimal numbers,

we can use the predefined type double,

which will allow us to work with decimal-type

variables.

What you have to know,

is that once we go through a declaration such as this,

each variable has its own type.

This type, will remain unchanged for the whole course of the program.

We cannot change the type of a variable

once the declaration has been made.

Concretely, this means that

our variable n here, can only contain integers.

Similarly, the variable x can only contain decimal numbers.

let us review these essential points.

In Java, the declaration of a variable, follows this syntax.

We specify the type of the variable,

follow by its identifier, its name.

And we do not forget the famous semicolon

which closes the declaration.

We have also seen that it is always recommanded

to give an intial value to our variable,

during the declaration.

We will generally adopt

a declaration-initialization instruction,

which goes as follows :

The variable type, followed by its name,

then, after the =, the initial value

and, of course, the semicolon at the end,

closing the declaration- initialization instruction.

Once the variable type has been defined,

it is clear that we can not change it later.

In Java, it is valid to declare several variables on the same line.

We will declare, on the same line, variables of the same type.

Therefore, we only specify the type once.

Here, we declare int-typed variables p and q,

separating the declaration of the different variables

with a comma.

You have here a second example

where we declare two double-typed variables on the same line.

The difference from the previous example,

is that, for the variable y we do not specify an initial value.

This is also possible.

Regarding methodology,

keep in mind that it is not recommanded to overuse these sorts

of formulation, for they impede the program's readability.

There are a few rules, by which you must abide

when choosing a variable's identifier.

This identifier can only be constituted

of letters, digits

or either of these specific characters : underscore (_) or dollar ($).

The first character has to be either a letter.

It can also be one of the specific characters

underscore (_) or dollar ($),

however, this is not part of the usual conventions

of Java programmers, which we will discuss later on.

Naturally, the identifier

cannot be one of the Java reserved keywords.

Capital letters are authorized,

but they are not equivalent.

For example, if we choose the identifier, "ligne" with a lower case "l",

it is not equivalent to the identifier "Ligne",

with an upper case "L".

You can see here examples of valid identifiers.

Here constituted of letters only,

here constituted of letters and digits.

Here, you can see some invalid identifiers.

Here, an identifier can neither contain a blank space.

nor the symbol minus (-) and cannot begin with a digit.

In addition to the naming rules imposed by the Java language,

which are to be strictly respected,

there are certain usual conventions,

not required by the compiler

but nonetheless respected by most Java programmers.

Typically, you will see the variable naming

with this form here.

If the name of the variable, the identifier, is constituted of several words,

we will separate the words,

starting every word with a capital letter.

Also, the convention is that every variable's identifier

is to start with a lower case letter.

Thus, you will encounter this type of formulation,

rather than this one, starting with a capital letter,

or this one, using underscores (_).

We have already understood that the notion of type

is essential for variable declaration in Java.

The two elementary types for the manipulation of numerical data,

that is, the declaration of numerical variables,

are int and double; we have already encountered them

in several of our previous examples.

Naturally, there are many another predefined type.

For example, if, in a program,

we wish to manipulate the usual characters of the alphabet,

for example A and Z,

we can resort to the predefined type char.

We will have the opportunity, throughout this course,

to expand on predefined types in Java.

Now, you know how to declare a variable,

making it possible to memorize a data,

usable in a program.

Now, how should we proceed, if we wish to change the value

of a variable, previously declared ?

To that end, we will resort to the notion of assignment.

We have already had the opportunity to encounter

a few informal examples.

In order to realize an assignment, we will use the symbol equals (=),

respecting the following syntax :

On the left side of the expression, we specify the variable's identifier.

Then comes our equal symbol (=)

and, finally, the new value

that we wish to store inside our variable.

It is very important to understand -

we will come back to this later -

that an assignment is not a mathematical equality.

its purpose is to modify the value of a variable,

in the course of the program's execution.

Let us suppose that, in a program, we declared two variables n and nCarré.

n has been declared and initalized to 4

while nCarré has not been initialized.

We wish to store a value inside nCarré, using the assignement notion.

How will such an assignment unfold ?

You must understand that the execution of such an instruction,

will occur in two distinct steps.

The first is the evaluation

of the expression on the right-hand side of the = symbol.

Here, this evaluation will give us the value 16.

In a second time, we will store the value thus computed

in the variable nCarré.

As a result,

the variable nCarré, will contain the value 16.

To sum up, the assignment syntax in Java is as follows :

we specify the name of the variable, followed by the equals symbol (=),

followed by an expression, valid in Java.

This expression can be something elementary,

such as a literal value, like here.

It can also be much more complex, like here.

We will come back to expressions and further discuss them later.

The critical point is that the type of the value

computed by the expression

must be the same as the variable's one

Another syntactic detail :

do not forget the semicolon (;) at the end of the assignment instruction.

Now, let us go back

to the comparison between the mathematical equality and the assignment.

Both use the equals sign (=)

and the notion of variables.

Self-evidently, if, in mathematics, we write such an expression,

we signify that the variables a and b

will always have the same value over time.

On the other hand, the assignment in programming

is a different mechanism entierely; it is dynamic

and will thus depend on time.

Let us take a concrete example.

Let us imagine that a contains the value 1 and b contains the value 2.

If we execute now this first instruction,

we start by, as we have just seen,

evaluating the expression on the right-hand side of the assignment;

this will give us the value 2.

Then, we will store this value, this 2, inside the variable a

which leads us to this result.

Now, let us analyze the second instruction

with the exact same starting conditions,

that is a containing 1 and b containing 2.

Now, if we execute this instruction,

as before, we start by evaluating what stands on the right side of the assignment,

returning 1.

Then, we store this 1 inside b, which results in this situation.

Thus, we see that in programming, in both cases,

a and b have the same value

but these values are not the same over time.

Moreover, if, at some point, one of the two variables is modified,

the other remains unaffected.

For example, if a is then modified to 3,

b will keep its value, for example 1, in the second assignment.

Another example : if, in mathematics,

we write such a relation, it means that a and b will awlays

verify this relation, regardless of the time.

However, if we write the exact same thing in programming,

we will see that the result for a and b is decidedly different.

Thus, here, we start by executing this instruction,

resulting in the variable a contaning 5.

Then, we execute this assignment instruction.

As we have seen before, we will start by evaluating "a + 1",

returning 6 and storing this 6 inside the variable b,

resulting in this situation.

At this point, a and b indeed verify this relation.

However, if we move on to the next instruction,

we will modify a's value to 2.

We now see that the relation is not verfied anymore.

Due to what we have just seen,

it is licit, in programing to resort to similar formulations.

By the way, this formulation, which you will often encounter,

along our examples is particularly useful.

Now, what happens if we execute such an instruction ?

Let us start with a concrete example, with a initialized to 1.

As we have just seen,

we start by evaluating this part of the assignement, returning 2.

In a second time, we will store this 2 inside a,

leading to this result.

Thus, when we write that kind of things in programming,

we do not signify, as is the case in mathematics,

that the relation "a = a + 1" must always be respected,

(in the context of mathematics, this particular expression may lead to problems)

In programming,

we simply signify that we are adding

1 to the value of a.

Now to the last chapter regarding variables :

the notion of constant.

We have seen that the assignment permits to modify

the value of a variable after its declaration.

There are situations, though, where this is not desirable.

Let us suppose that, in a program, we need to work

with the speed of light.

We all know that the speed of light is a constant.

Its value will thus not be modified over the course of the program.

Therefore, we will precise that this data cannot change.

In such a case, we proceed by adding the reserved

keyword "final" just before the variable declaration.

This means that, once an initial value has been attributed,

we cannot modify the value of the variable anymore.

Here, in this example, we declared our constant as follows :

the constant VITESSE_DE_LA_LUMIERE (TN:vitesse de la lumière means speed of light)

If, later on, we try to modify the value

through an assignment, this will result in a compiling error.

By the way, there are certain conventions

regarding the naming of constants in Java.

Here, the identifier of our speed of light constant

is constituted by different words, all written in capital letters

and separated by underscores (_).

This is a usual convention regarding the naming of constants.

We warmly recommand you to follow these conventions.

Explorer notre catalogue

Rejoignez-nous gratuitement et obtenez des recommendations, des mises à jour et des offres personnalisées.

Coursera propose un accès universel à la meilleure formation au monde, en partenariat avec des universités et des organisations du plus haut niveau, pour proposer des cours en ligne.

© 2018 Coursera Inc. Tous droits réservés.

Télécharger dans l'App Store

Disponible sur Google Play