Cours 2 - Introduction Java

name: inverse
layout: true
class: center, middle, inverse

---
# JAVA - Cours 2
## Introduction JAVA
## Inès de Courchelle

![image](img/CY-tech.png)

---
layout: false
# Introduction
## Java c’est quoi ?
- Langage Orienté objet
- Un ensemble complet d’API
  - Réseau
  - Graphique
  - Sécurité
  - ...
- Syntaxe inspirée du C++
- Langage compilé
- Gestion de la mémoire dynamique (pas de pointeur)
- Gratuit (pour le moment !)
- ...

---
# Introduction
## Orienté objet
- Des Classes
- Des Méthodes
- Des primitifs
- Les objets se manipulent via des références

## Spécificités
- A l’origine, c’est un langage pour les applications embarquées !
- La mémoire est gérée par un *“garbage collector”*
- Le compilateur Java génère du *byte code*, c’est un intermédiaire entre le code machine et le langage
- L’environnement d’exécution de ce *byte code* est une JVM

---
# Compilation et exécution
## Fonctionnement
- Les fichiers sources se terminent par “.java”
- Le nom du fichier est le même que la classe

```bash
javac NomDuProgramme.java
java NomDuProgramme
```

## Que se passe t-il en interne ?
- Génération de fichiers
- Type des fichiers générés : .class
- Exemple :
```bash
NomDuProgramme.class
```
---
# Compilation et exécution
## javac
<img src="img/javac.png"  width=450/>

## La machine virtuelle appelle la méthode main
```java
public static void main(String[] args){
    ...
    ...
}
```
---
# Les variables
## Utilisation
- **Déclaration** type-variable
```java
<type> nomVariable;
```
- **Affectation**
```java
<type> nomVariable=valeur;
```
- **Initialisation** type-variable
```javan
<type> nomVariable=valeur;
```
- **Les constantes** : elles sont déclarées par le mot clé final
```java
    final <type> nomVariable=valeur;
```
---
# Les variables
## Les règles
- Noms sensibles à la casse (les majuscules)
- Caractères alphanumériques déconseillés (\_, \$ ...)
- Variable à mot unique sans majuscule
- Variable à mots multiples :
  - Minuscule au début
  - Majuscule à la fin

---
# Les types primitifs
## Définition
- Contrairement à certains langages comme Python, Javascript, **le Java est typé** !!
- Il y a 8 types primitifs :
    - boolean
    - byte
    - char
    - short
    - int
    - long
    - float
    - double
- Les types primitifs occupent une certaine place de mémoire selon leur définition
- Les variables peuvent être déclarées n’importe où !

---
# Les types primitifs
## Les types courts

|       |         |          |
|-------|---------|----------|
| byte  | 8 bits  | 1 octet  |
| int   | 32 bits | 4 octets |
| float | 32 bits | 4 octets |

## Les types longs

|        |         |          |
|--------|---------|----------|
| short  | 16 bits | 2 octet  |
| long   | 64 bits | 8 octets |
| double | 64 bits | 8 octets |

## Les types nom numériques
|         |         |          |
|---------|---------|----------|
| boolean | true    | false    |
| char    | 16 bits | 8 octets |

---
# Les tableaux
## C'est quoi ?
C’est un conteneur << static >> comme en C
<img src="https://media.giphy.com/media/26FmPNdnmllMwkoTK/giphy.gif"  width=100/>

Impossible de changer sa taille après sa définition

## Exemples
```java
int[] tableauEntier;
tableauEntier = new int[100];
```
---
# Les tableaux 2/2
## Initialisation + déclaration << static >>
```java
int [] tableauEntier = {1,2,3};
```
## La matrice
```java
int [][] matriceEntier = {{1,2,3},{4,5,6}};
```
## Manipulation
```java
tableauEntier[1] = 5;
matriceEntier[0][1] = 5;
```
---
# Les opérateurs
## Définition
Ce sont les mêmes qu’en C :
- **Affectation :** =
- **Arithmétiques :** + - \* et /
- **Comparaisons :**< , <= , > , >= , == , et !=
- **Logiques:** ! || et &&
- **Incrémentation et décrémentation :** ++ et --

## Attention
Les comparaisons portent uniquement sur des valeurs de type primitifs.

---
## Les instructions conditionnelles

.pull-left[
```java
if (cond){
  instructions;
}
else {
  instructions;
}
```
]

.pull-right[
```java
switch(ex1){
case ex2 :
  instructions;
  break;
case ex3 :
  instructions;
  break;
default :
  instructions;
  break;
}

```
]
<center>
    <img src="img/c.jpg"  width=250/>
</center>

---
# Les boucles
## Les classiques
.pull-left[
```java
while(cond){
  instructions;
}
do {
  instructions;
}while(cond);

```
]
.pull-right[
```java
for(int i=0;i<= 10;i++)
{
  instructions;
}
```
]
<center>
    <img src="img/it_while_do.jpg"  width=400/>
</center>

---
# Mon premier programme
## Helloworld
```java
public class Helloworld {
    public static void main (String args []){
        System.out.println("Mon premier programme");
    }
}
```
<center>
    <img src="https://media.giphy.com/media/2xPPojqe3mraUXS6dk/giphy.gif"  width=100/>
</center>

- Le nom du fichier doit avoir le même nom que la classe
- Ici, le fichier doit être enregistré avec le nom suivant :
```bash
Helloworld.java
```

---
# ANT 1/4
## Définition
- Architecture Multiplateforme
- Indépendant du système (et du shell)
- Basé sur du XML

## Objectifs
- Configuration de la compilation
- Automatisation des tâches de pré-compilation et post-compilation
- Archivage
- Test
- ...

---
# ANT 2/4
## Principes
- 1 fichier de configuration : build.xml (nom par défaut)
- Équivalent du fichier Makefile en C
- Définir un ensemble de target
- Configurer les dépendances entre les cibles

---
# ANT 3/4
## Le développeur doit créer (c'est-à-dire VOUS)
  - 1 seul fichier à la racine du projet : build.xml
  - 1 répertoire pour les différentes sources Java
  - 1 répertoire pour les librairies externes (optionnel)

## ANT peut créer (tout seul)
1 répertoire build qui contient
  - Les fichiers compilés (.class)
  - Les librairies générées (.jar)
  - Documentations ...

---
# ANT 4/4
## Exemple de build.xml
```xml
<?xml version="1.0" encoding="utf-8" ?>
<project>
<target name="compile">
  <mkdir dir="build/classes/"/>
  <javac srcdir="src" destdir="build/classes"/>
</target>
<target name="run">
  <java classpath="build/classes" classname="Helloworld"/>
</target>
<target name="clean">
  <delete dir="build"/>
</target>
</project>
```