Classe : [Link](I.

T) SEM - IV Subject : Core Java

Java de base
Classe : [Link](I.T)
Classe : [Link](I.T) SEM - IV Subject : Core Java

Index
Chapitre Nom
Non.
1 Introduction
2 Opérateurs en Java
3 Déclarations en Java
4 Boucles en Java
5 Liste des programmes

6 Tableaux et chaînes
7 Gestion des exceptions
8 OUPS
9 Héritage
10 Multithreading
11 Forfaits
Classe : [Link](I.T) SEM - IV Sujet : Java de base

1 - Introduction

Qu'est-ce que Java ?

Java est un langage de programmation purement orienté objet.

Un programme Java est principalement une collection d'objets qui communiquent avec d'autres objets par
invoquant les méthodes de l'autre.

Chaque objet est d'un certain type, et ce type est défini par une classe ou un
interface.

La plupart des programmes Java utilisent une collection d'objets de nombreux types différents.

Classe

Un modèle qui décrit les types d'état et de comportement que les objets de celui-ci
soutien de type.
Objet
Au moment de l'exécution, lorsque la machine virtuelle Java (JVM) rencontre le nouveau
mot-clé.

il utilisera la classe appropriée pour créer un objet qui est une instance de cela
classe.

Cet objet aura son propre état et accès à tous les comportements définis.
by its class.
États (variables d'instance)

Chaque objet (instance d'une classe) aura son propre ensemble unique d'instances
variables telles que définies dans la classe.

Collectivement, les valeurs assignées aux variables d'instance d'un objet constituent le
état de l'objet.
Classe : [Link](I.T) SEM - IV Sujet : Java de base

Comportement (méthodes)

When a programmer creates a class, He/She creates methods for that class.

Les méthodes sont l'endroit où la logique de la classe est stockée.

Les méthodes sont là où le vrai travail est fait.

Ils sont là où les algorithmes sont exécutés et les données sont manipulées.

Features Of Java:-
Classe : [Link](I.T) SEM - IV Subject : Core Java

Indépendant de la plateforme

Simple
Orienté objet
Robuste
Distribué
Portable
Dynamique
Securisé
Performance
Interprété

Indépendant de la plateforme

Le concept de Écrire une fois, exécuter partout (connu sous le nom de Plateforme indépendante) est
l'une des fonctionnalités clés importantes du langage Java qui fait de Java le plus
powerful language.

Pas même une seule langue n'est inoccupée pour cette fonctionnalité, mais Java s'en rapproche davantage.
caractéristique.

Les programmes écrits sur une plateforme peuvent fonctionner sur n'importe quelle plateforme à condition que

la plateforme doit avoir la JVM.

Simple

Il existe diverses caractéristiques qui rendent Java un langage simple.

Les programmes sont faciles à écrire et à déboguer car Java n'utilise pas de pointeurs.
explicitement.

Java offre un système sans bugs grâce à une gestion de mémoire efficace. Il offre également
dispose d'un système d'allocation et de désallocation de mémoire automatique.
 Classe : [Link](I.T) SEM - IV Sujet : Java de base

Orienté objet

To be an Object Oriented language, any language must follow at least the four
caractéristiques comme suit.

Héritage : C'est le processus de création de nouvelles classes et d'utilisation du comportement de

les classes existantes en les étendant juste pour réutiliser le code existant et ajouter le
fonctions supplémentaires selon les besoins.

L'encapsulation : C'est le mécanisme de combinaison des informations et de la fourniture du

L'encapsulation est le processus de dissimulation des détails de la classe externe.

Polymorphisme : Comme son nom l'indique, un nom multiple formes, le polymorphisme est le
manière de fournir différentes fonctionnalités par des fonctions ayant le même nom
basé sur les signatures des méthodes.

Liaison dynamique : Parfois, nous n'avons pas connaissance des objets à propos de leur
des types spécifiques lors de l'écriture de notre code. C'est la façon de fournir le
fonctionnalité maximale à un programme concernant le type spécifique à l'exécution.

Robuste

Java a un mécanisme d'allocation de mémoire solide et de collecte automatique des déchets.

It provides the powerful exception handling and type checking mechanism as
comparé à d'autres langages de programmation.
Compiler checks the program whether there any error and interpreter checks any
erreur d'exécution et rend le système sécurisé contre les crashs.
Toutes les fonctionnalités ci-dessus rendent le langage Java robuste.

Distribué
o Les protocoles largement utilisés comme HTTP et FTP sont développés en Java.
o Les programmeurs Internet peuvent appeler des fonctions sur ces protocoles et peuvent y accéder.
fichiers d'une quelconque machine distante sur Internet plutôt que d'écrire des codes sur leur
système local.

Portable

The feature Write-once-run-anywhere makes the java language portable provided

que le système doit avoir un interpréteur pour la JVM.
Class : [Link](I.T) SEM - IV Sujet : Java de base

Java also have the standard data size irrespective of operating system or the
processeur. Ces caractéristiques rendent Java un langage portable.

Dynamique
Lors de l'exécution du programme Java, l'utilisateur peut obtenir les fichiers requis dynamiquement.
d'un disque local ou d'un ordinateur à des milliers de kilomètres de l'utilisateur juste par
connexion à Internet.

Securisé

Java n'utilise pas les pointeurs en mémoire de manière explicite.

Tous les programmes en java s'exécutent dans une zone appelée le bac à sable.
Le responsable de la sécurité détermine les options d'accessibilité d'une classe telles que la lecture et
écriture d'un fichier sur le disque local.

Java utilise le système de cryptage par clé publique pour permettre aux applications Java de transmettre.
sur Internet sous une forme sécurisée et cryptée.

Le vérificateur de bytecode vérifie les classes après les avoir chargées.

Performance

Java utilise un code natif et un processus léger appelé threads.

Au début, l'interprétation du bytecode entraînait une lenteur des performances, mais le

La version avancée de la JVM utilise la technique de compilation adaptative et à la volée.
cela améliore la performance.

Interprété

Nous savons tous que Java est également un langage interprété. Avec un interprété
des langages comme Java, les programmes s'exécutent directement à partir du code source.

Le programme d'interprétation lit le code source et le traduit à la volée en

calculs. Ainsi, Java en tant que langage interprété dépend d'un interpréteur
programme.
Classe : [Link](I.T) SEM - IV Sujet : Java de base

Un autre avantage de Java en tant que langage interprété est sa qualité de débogage des erreurs.
En raison de cela, toute erreur survenant dans le programme est répertoriée. C'est ainsi que c'est différent.
travailler avec Java.

Liaison dynamique :-

Java prend en charge un paradigme novateur pour le déploiement de code : au lieu de lier un ensemble complet
avant l'exécution, les classes et les interfaces qui composent le programme sont
chargé et lié à la demande pendant l'exécution.

Les classes sont vérifiées avant la création des objets. La vérification vérifie les sous-types, et
peut nécessiter le chargement de classes ou d'interfaces supplémentaires.

Lorsque vous compilez un programme Java, vous obtenez un fichier de classe distinct pour chaque classe ou
interface dans votre programme.

Bien que les fichiers de classe individuels puissent sembler indépendants.

Lorsque vous exécutez votre programme, la machine virtuelle Java charge les classes de votre programme.
et les interfaces et les relie ensemble dans un processus de liaison dynamique.

Au fur et à mesure que votre programme s'exécute, la machine virtuelle Java construit un réseau interne de

classes et interfaces interconnectées.

Le modèle de liaison Java est plus complexe que celui généralement trouvé dans la programmation.
langues.
Avantages :

Le démarrage est plus rapide, car il y a moins de code à charger au départ.

Les programmes en cours d'exécution se lient à chaque fois avec la version la plus à jour de n'importe quel utilitaire.
La détection d'erreurs est plus paresseuse, car des exceptions ne sont lancées que s'il y a une tentative de
exécuter du code non sécurisé.

Pourquoi Java utilise-t-il la collecte automatique des ordures ?

Lorsque un objet Java devient injoignable pour le programme, il est soumis à

collecte des déchets.

L'utilisation principale de la collecte des déchets est d'identifier et de jeter les objets qui ne sont plus
plus longtemps nécessaire par un programme afin que ses ressources puissent être récupérées et réutilisées.

Lorsque un objet n'est plus référencé par aucune variable, Java le récupère automatiquement.
mémoire utilisée par cet objet. Cela est connu sous le nom de collecte des ordures.
Classe : [Link](I.T) SEM - IV Subject : Core Java

La méthode [Link]() peut être utilisée pour l'appeler explicitement.

Pourquoi Java est-il architecturale neutre ?

Java a été conçu pour supporter des applications sur des réseaux.
En général, les réseaux sont composés d'une variété de systèmes avec une variété de
Architectures de processeur et de système d'exploitation.

To enable a Java application to execute anywhere on the network, the

le compilateur génère un format de fichier objet neutre en architecture - le compilé
le code est exécutable sur de nombreux processeurs, grâce à la présence de Java
système d'exécution.
Cela est utile non seulement pour les réseaux, mais aussi pour les logiciels de système unique.
distribution.
Le compilateur Java le fait en générant des instructions bytecode qui ont
rien à voir avec une architecture informatique particulière.
Au contraire, ils sont conçus pour être à la fois faciles à interpréter sur n'importe quelle machine et
easily translated into native machine code
Classe : [Link](I.T) SEM - IV Sujet : Java de base

Le processus d'exécution en Java (Java Virtual Machine)

Machine Virtuelle Java (JVM)

Classe : [Link](I.T) SEM - IV Sujet : Java de base

Le code est développé soit dans un éditeur de texte simple, soit dans un environnement de développement intégré.

Environnement (IDE) et sauvegardé dans un fichier avec une extension .java.

Il est alors vérifié pour les erreurs de syntaxe par le compilateur Java([Link]).

Si la compilation est réussie, le fichier .class résultant est passé à la machine virtuelle Java.
Machine([Link])pour exécution.

L'action de compiler a un effet double : d'abord, le code est vérifié pour sa syntaxe.
erreurs et deuxièmement, le code est converti en codes octets.

Les codes octets sont des instructions pour une machine imaginaire appelée la machine virtuelle Java
Machine (JVM).

Cette machine est émulée par tous les interprètes Java et permet donc de
exécuter un programme Java compilé sur différentes plateformes (systèmes d'exploitation)
avec une JVM).

ByteCode
Le bytecode Java est la forme d'instructions que la machine virtuelle Java exécute.

Chaquele bytecode estune longueur d'un octet, bien que certains nécessitent des paramètres, ce qui entraîne
certaines instructions multioctets.

Le format de code byte est le même sur toutes les plateformes car il s'exécute dans la même JVM et il est
totalement indépendant du système d'exploitation et de l'architecture du CPU.

JVM:-

C'est le composant principal de l'architecture Java qui fournit la compatibilité multiplateforme.

fonctionnalité et sécurité à Java.

Ceci est un processus logiciel qui convertit le code byte Java compilé en langage machine.
code.

Le bytecode est un langage intermédiaire entre le code source Java et le système hôte.
Classe : [Link](I.T) SEM - IV Sujet : Java de base

La plupart des langages de programmation comme C et Pascal traduisent le code source en

code machine pour un type spécifique de machine, car le langage machine varie d'une
système à système. Donc, la plupart des compileurs produisent du code pour un système particulier, mais Java
le compilateur produit du code pour une machine virtuelle.

La traduction se fait en deux étapes. D'abord, les programmes écrits en Java ou le code source
le code traduit par le compilateur Java en bytecode et après cela, la JVM convertit le
bytecode en code machine pour l'ordinateur sur lequel on souhaite exécuter.

Ainsi, les fichiers de programmes écrits en Java sont stockés dans des fichiers .java et les fichiers .java sont
compilé par le compilateur Java en code byte qui est stocké dans un fichier .class. La JVM
plus tard, le convertir en code machine.

En fait, le format de bytecode est le même sur toutes les plateformes car il s'exécute dans la même JVM et il
est totalement indépendant du système d'exploitation et de l'architecture du processeur.

La JVM fait partie de l'environnement d'exécution Java qui est requis par chaque système d'exploitation.
Le système nécessite un JRE différent.

JRE se compose d'un certain nombre de classes basées sur l'API Java et la JVM, et sans JRE, il est
impossible d'exécuter Java.

Java Java Java

Programme Compilateur Virtuel

Java Java Machine

ByteCode Interpréter Code

Commentaires
Les commentaires sont essentiellement utilisés pour la documentation des programmes.
Les commentaires sont simplement du texte ignoré par le compilateur, mais qui peuvent informer le
lecteur de ce que vous faites à un moment donné dans votre programme.

Types de commentaires
Il existe deux types de commentaires.
1) commentaire double-slash (//).
Classe : [Link](I.T) SEM - IV Sujet : Java de base

2) commentaire slash-astérisque (/*).

Le commentaire à double slash, qui sera appelé un commentaire de style Java, indique
le compilateur pour ignorer tout ce qui suit ce commentaire, jusqu'à la fin du
ligne.

Le marqueur de commentaire slash-astérisque indique au compilateur d'ignorer tout ce qui suit.

jusqu'à ce qu'il trouve un marqueur de commentaire étoile-barre (*/)

Ces marques seront appelées des commentaires de style Java. Chaque /* doit être apparié.
avec une fermeture */.
Instruction Print en Java :

[Link]("Chaîne");

La déclaration ci-dessus est utilisée pour afficher un message sur la console.

Le système est une classe qui est définie dans un package [Link].*.

Out est un objet de la classe System.

Println("String") est la méthode de la classe System qui est utilisée pour imprimer un message.
sur la console.
Exemple :
[Link]("HelloWorld!!!");
La déclaration ci-dessus affiche le message Bonjour le monde !!! dans la console.

VARIABLES

Les variables sont un moyen de réserver de la mémoire pour contenir des données et d'assigner des noms à
eux afin que nous n'ayons pas à nous souvenir des numéros comme 46735 et à la place nous
can use the memory location by simply referring to the variable.

Chaque variable est associée à une adresse mémoire unique. Par exemple, nous avons 3
variable v1, v2, v3. Ils peuvent se voir assigner les adresses mémoire 32000, 12456,
67893 respectivement. Voici l'illustration.
Syntaxe :
Type de données Nom_Du_Variable;
Eg:-
int v1; Int v3; Int v3;
Classe : [Link](I.T) SEM - IV Sujet : Java de base

Il précise qu'il y a trois variables v1, v2, v3 (nommées par le programmeur) et

ont attribué
les emplacements mémoire 32000, 12456 et 67893.
Ces emplacements mémoire ne sont pas leurs valeurs. Les valeurs des variables sont ce que
vous leur assignez. Vous pouvez attribuer la valeur 86 à v1, 32,45 à v2 et 'a' à v3.

Règles pour la construction des noms de variables

[Link] nom de variable est toute combinaison de 1 à 31 lettres, chiffres ou

traits de soulignement.
Le premier caractère du nom de la variable doit être une lettre de l'alphabet ou un tiret bas.
3. Aucun virgule ni espace n'est autorisé dans un nom de variable.
4. Aucun symbole spécial autre qu'un souligné (comme ingross_sal) ne peut être utilisé dans un
nom de variable.
[Link].: si_int

Littéral
Une valeur constante dans un programme est désignée par un littéral. Les littéraux représentent des valeurs numériques.
(entier ou nombre à virgule flottante), caractère, valeur booléenne ou chaîne de caractères.

Exemple de littéraux :

Littéraux entiers :
33 0 -9

Littéraux à virgule flottante :

.3 0.3 3.14

Littéraux de caractères :
( 'R' 'r' '{'

Littéraux booléens : (valeurs prédéfinies)

vrai faux

Littéraux de chaîne :
"language" "0.2" "r" ""
Littéraux entiers
Les littéraux entiers sont une séquence de chiffres et un suffixe en tant que L.
Pour représenter le type en tant qu'entier long, nous utilisons L comme suffixe.
Nous pouvons spécifier les entiers soit en décimal, soit en hexadécimal ou en octal.
Pour indiquer un format décimal, placez le chiffre le plus à gauche en tant que non nul. De même, mettez le
caractères comme ox à gauche d'au moins un chiffre hexadécimal pour indiquer l'hexadécimal
Classe : [Link](I.T) SEM - IV Subject : Core Java

format. Also we can indicate the octal format by a zero digit followed by the digits 0
à 7. Ex.
littéral entier décimal de
659L
type entier long
Entier hexadécimal
0x4a
littéral de type entier
littéral entier octal de
057L
type entier long

Littéraux de caractère
Nous pouvons spécifier un littéral de caractère comme un seul caractère imprimable dans une paire de simples
citez des caractères tels que 'a', '#', et '3'.
Vous devez connaître le jeu de caractères ASCII. Le jeu de caractères ASCII comprend
128 caractères y compris les lettres, les chiffres, la ponctuation, etc.
Il existe quelques littéraux de caractères qui ne peuvent pas être facilement imprimés par un clavier.
Le tableau ci-dessous montre les codes qui peuvent représenter ces caractères spéciaux. Le
La lettre d, comme dans l'octal, l'hexadécimal, etc. représente un nombre.
Signification d'évasion

\n Nouvelle ligne

Onglet
Retour arrière
Charrette
\r
retourner
\f Saut de page
\\ Barre oblique inversée
Célibataire
\' citation
marque
Double
\" citation
marque
\d Octale
\xd Hexadécimal
Unicode
caractère

Littéraux booléens
Les valeurs true et false sont également traitées comme des littéraux en programmation Java.
Lorsque nous assignons une valeur à une variable booléenne, nous ne pouvons utiliser que ces deux valeurs.
Classe : [Link](I.T) SEM - IV Subject : Core Java

Contrairement à C, nous ne pouvons pas présumer que la valeur de 1 est équivalente à vrai et 0 est
équivalent à faux en Java. Nous devons utiliser les valeurs vrai et faux pour représenter un
Valeur booléenne.
Comme
boolean choisi = true;
Rappelez-vous que le vrai littéral n'est pas représenté par les guillemets qui l'entourent.
Le compilateur Java le considérera comme une chaîne de caractères, si elle est entre guillemets.

Littéraux à virgule flottante

Les nombres à virgule flottante sont comme des nombres réels en mathématiques, par exemple, 4.13179,
-0,000001.
Java a deux types de nombres à virgule flottante : float et double.
Le type par défaut lorsque vous écrivez un littéral à virgule flottante est double.
Type Size Plage Précision
nom octets bits approximatif en chiffres décimaux
flottant 4 32 +/- 3,4 * 10^38 6-7
double 8 64 +/- 1.8 * 10308 15
Un littéral à virgule flottante peut être désigné comme un point décimal, une partie fractionnaire, un
exposant (représenté par E ou e) et sous forme d'entier.
Nous ajoutons également un suffixe au littéral à virgule flottante sous forme de D, d, F ou f.
Le type d'un littéral à virgule flottante par défaut est à virgule flottante de double précision.
Les littérales de nombres à virgule flottante suivants représentent des nombres à virgule flottante double précision et
valeurs à virgule flottante.
6,5E+32 Double précision
(ou 6,5E32) littéral à virgule flottante
Double précision
7D littéral à virgule flottante
Flottant
.01f
littéral

Littéraux de chaîne
La chaîne de caractères est représentée sous forme de littéraux String en Java.
En Java, une chaîne n'est pas un type de données de base, mais plutôt un objet.
Ces chaînes ne sont pas stockées dans des tableaux comme en langage C.
Il existe peu de méthodes fournies en Java pour combiner des chaînes, modifier des chaînes et pour
savoir si les chaînes ont la même valeur.

Nous représentons les littéraux de chaîne comme

String myString = "How are you?";

L'exemple ci-dessus montre comment représenter une chaîne. Elle se compose d'une série de
caractères à l'intérieur des guillemets.
Classe : [Link](I.T) SEM - IV Subject : Core Java

Voyons quelques exemples supplémentaires de littéraux de chaîne :

"" // the empty string

"\"" // a string containing "
Ceci est une chaîne // une chaîne contenant 16 caractères
Ceci est un // en fait, une expression constante de type chaîne,
chaîne en deux lignes // formé à partir de deux littéraux de chaîne
Les chaînes peuvent également inclure les codes d'échappement de caractère, comme montré ici :
String example = "Your Name, \"Sumit\"";
[Link]("Thankingyou,\nRichards\n");

Littéraux nuls
Le dernier littéral que nous pouvons utiliser en programmation Java est un littéral null.
Nous spécifions le littéral Null dans le code source comme 'null'.
Pour réduire le nombre de références à un objet, utilisez le littéral null.
Le type du littéral nul est toujours nul. Nous assignons généralement des littéraux nuls à des objets.
variables de référence. Par exemple

s = null;

Types de données

Chaque variable en Java a un type de données.

Les types de données spécifient la taille et le type des valeurs qui peuvent être stockées dans la mémoire.
Le langage Java est riche en types de données.
La syntaxe générale pour déclarer le type de données est
Data_type Name_of_variable;
Ex : int num;
Les entiers représentent des nombres entiers qui ne contiennent pas de point décimal.

Toutes les expressions suivantes sont des entiers :

45 -932 0 12 5421

Les nombres à virgule flottante contiennent des décimales. Ils sont connus sous le nom de nombres réels.
mathématiciens.

Toutes les expressions suivantes sont des nombres à virgule flottante, et tout nombre à virgule flottante
la variable peut les contenir :

45,12 -2344,5432 0,00 0,04594

Classe : [Link](I.T) SEM - IV Sujet : Java de base

Type Range*

char–128 à 127

caractère non signé de 0 à 255

char signé –128 à 127

int–32768 à 32767

entier non signé de 0 à 65535

int signé –32768 à 32767

entier court –32768 à 32767

entier non signé court de 0 à 65535

entier court signé –32768 à 32767

long int–2147483648 à 2147483647

entier long signé de –2147483648 à 2147483647

flottant -3,4E-38 à 3,4E+38

double – 1,7E–308 à 1,7E+308

long double –3,4E–4932 à 1,1E+4932

Classe : [Link](I.T) SEM - IV Sujet : Java de base

2 - Opérateurs en Java

Opérateur :

Les opérateurs sont des symboles qui prennent un ou plusieurs opérandes ou expressions et effectuent
calculs arithmétiques ou logiques.

Le langage de programmation Java fournit plusieurs opérateurs pour effectuer différents types de
opérations. Il existe des opérateurs pour l'affectation, les fonctions arithmétiques, les fonctions logiques et
beaucoup plus.

Ces opérateurs fonctionnent généralement sur de nombreux types de variables ou de constantes, bien que certains soient
restreints à travailler sur certains types. La plupart des opérateurs sont binaires, ce qui signifie qu'ils prennent deux

opérandes.

Quelques-uns sont unaires et n'utilisent qu'un seul opérande.

• Opérateur d'assignation noté par =

• Les opérateurs arithmétiques désignés par +, -, *, /, %
• Les opérateurs d'affectation composés représentés par +=, -=, *=, /=, %=, >>=, <<=, &=, ^=, |=
• Opérateur d'incrément et de décrément désigné par ++, --
• Opérateurs relationnels et d'égalité notés par ==, !=, >, <, >=, <=
• Opérateurs logiques désignés par !, &&, ||
• Opérateur conditionnel désigné par ?
• L'opérateur virgule désigné par ,
• Opérateurs binaires notés par &, |, ^, ~, <<, >>
• Opérateur de conversion de type explicite

Opérateur d'assignation

• Ceci est désigné par le symbole =.

• Cet opérateur est utilisé pour assigner une valeur à une variable.
• La gauche de l'opérateur d'assignation est connue sous le nom de lvalue (valeur de gauche), qui doit
sois une variable.
• Le côté droit de l'opérateur d'assignation est connu sous le nom de rvalue (valeur de droite). La rvalue
peut être une constante, une variable, le résultat d'une opération ou toute combinaison de ceux-ci.

Par exemple :
x = 5;
Classe : [Link](I.T) SEM - IV Sujet : Java de base

En suivant la règle de gauche à droite, la valeur 5 est assignée à la variable x ci-dessus

déclaration d'affectation.

Opérateurs arithmétiques

Les opérateurs utilisés pour les opérations arithmétiques en JAVA sont :

• + Pour addition
• Pour la soustraction
• * Pour la multiplication
• / Pour la division
• % Pour modulo
Exemple :
classe Ajouter
{
public static void main(String args[])
{
int n1 = 3;

int n2 = 6;

int somme = n1 + n2;

int div = n2 / n1;

int mod = n2 % n1;

int diff;
si(n1 > n2)
{
diff = n1 - n2;

}
sinon
{
diff = n2 - n1;

[Link]("Somme="+sum);
[Link]("Différence="+diff);
[Link]("Division="+div);
[Link]("Modulas="+mod);
}
}
Classe : [Link](I.T) SEM - IV Sujet : Java de base

Opérateurs d'affectation composés

• Cet opérateur est utilisé lorsqu'un programmeur souhaite mettre à jour une valeur actuelle en
effectuer une opération sur la valeur actuelle de la variable.
• Par exemple :
Vieux += nouveau est égal à
Ancien = ancien + nouveau

Les opérateurs d'affectation composés fonctionnent de manière similaire aux autres opérateurs +=, -=, *=
/=, %=, >>=, <<=, &=, ^=, |= fonction.

Opérateur d'incrément et de décrément

• L'opérateur d'incrément est noté par ++ et l'opérateur de décrément par --.

• La fonction de l'opérateur d'incrément est d'augmenter la valeur et le décrément
l'opérateur est de diminuer la valeur.
• Ces opérateurs peuvent être utilisés comme préfixes ou suffixes.
• Un opérateur de préfixe est écrit avant la variable comme ++a ou –a.
• Un opérateur postfixe est écrit après la variable comme a++ ou a--.

La fonctionnalité des opérateurs de préfixe et de post-fixe

• Dans le cas où l'opérateur d'incrément ou de décrément est utilisé comme préfixe ( ++a ou –a),
alors la valeur est respectivement augmentée ou diminuée avant que le résultat de l'expression ne soit
évalué.
• Par conséquent, la valeur augmentée ou diminuée, respectivement, est considérée dans l'extérieur.
expression.
• Dans le cas où l'opérateur d'incrémentation ou de décrémentation est utilisé en postfixe (a++ ou a--)
), alors la valeur stockée dans a est respectivement augmentée ou diminuée après avoir été évaluée.
• Par conséquent, la valeur stockée avant l'opération d'augmentation ou de diminution est évaluée dans
l'expression extérieure.
Par exemple :
y=3;
x=++y; //Préfixe : Ici, la valeur de x devient 4

Mais pour l'opérateur postfixe, à savoir comme ci-dessous :

y=3 //Postfix : Ici la valeur de x est 3 et la valeur de y est 4

x=y++;
Class : [Link](I.T) SEM - IV Sujet : Java de base

Exemple :
/* Program to demonstrates the increment operator*/

classe IncDec
{
public static void main(String args[])
{
int a = 10;
int b = 20;
int c,d;
c = ++b;
d = a++;
[Link]("a = " + a);
[Link]("b = "+b);
[Link]("c = " + c);
[Link]("d = " + d);
}
}

Opérateurs relationnels et d'égalité

• Ces opérateurs sont utilisés pour évaluer une comparaison entre deux expressions.
• La valeur retournée par l'opération relationnelle est une valeur booléenne (vrai ou faux)
valeur).
Les opérateurs utilisés à cet effet en JAVA sont :
Opérateurs relationnels et d'égalité ( ==, !=, >, <, >=, <= )

Afin d'évaluer une comparaison entre deux expressions, nous pouvons utiliser le relationnel et
opérateurs d'égalité. Le résultat d'une opération relationnelle est une valeur booléenne qui ne peut être que
vrai ou faux, selon son résultat booléen.

Nous pouvons vouloir comparer deux expressions, par exemple, pour savoir si elles sont égales ou si l'une
est supérieur à l'autre. Voici une liste des opérateurs relationnels et d'égalité qui peuvent être
utilisé en JAVA :
== Égal à
!= Pas égal à
> Plus grand que
< Moins de
>= Supérieur ou égal à
<= Moins que ou égal à
Classe : [Link](I.T) SEM - IV Subject : Core Java

Voici quelques exemples :

(7 == 5) // évalue à faux.
(5 > 4) // évalue à vrai.
(3 != 2) // evaluates to true.
(6 >= 6) // évalue à vrai.
(5 < 5) // évalue à faux.

Bien sûr, au lieu d'utiliser uniquement des constantes numériques, nous pouvons utiliser n'importe quelle expression valide.

y compris les variables. Supposons que a=2, b=3 et c=6,

(a == 5) // évalue à faux car a n'est pas égal à 5.
(a*b >= c) // évalue à vrai puisque (2*3 >= 6) est vrai.
(b+4 > a*c) // évalue à faux puisque (3+4 > 2*6) est faux.
((b=2) == a) // évalue à vrai.
Remarque :
L'opérateur = (un signe égal) n'est pas le même que l'opérateur == (deux signes égaux), le
le premier est un opérateur d'assignation (assigne la valeur à sa droite à la variable à sa gauche)
et l'autre (==) est l'opérateur d'égalité qui compare si les deux expressions dans
les deux côtés sont égaux l'un à l'autre. Ainsi, dans la dernière expression ((b=2) == a), nous d'abord
attribué la valeur 2 à b et ensuite nous l'avons comparé à a, qui stocke également la valeur 2, donc le
le résultat de l'opération est vrai.

Opérateurs logiques ( !, &&, || )

• Les opérateurs logiques, ET logique (&&) et OU logique (||), sont utilisés pour combiner
des conditions multiples formées à l'aide d'expressions relationnelles ou d'égalité.
• L'opérateur logique ET (&&) renvoie la valeur booleanne vraie si les deux opérandes sont
vrai et renvoie faux sinon.

• Les opérandes sont implicitement convertis en type bool avant l'évaluation, et le

le résultat est de type bool. L'AND logique a une associativité de gauche à droite.
• Les opérandes de l'opérateur logique ET n'ont pas besoin d'être du même type, mais ils
doit être de type entier ou pointeur.
Classe : [Link](I.T) SEM - IV Subject : Core Java

Opérateur logique NON

• L'opérateur ! est l'opérateur JAVA pour effectuer l'opération booléenne NON, il a

seul un opérande, situé à sa droite, et la seule chose qu'il fait est d'inverser la valeur
de cela, produisant faux si son opérande est vrai et vrai si son opérande est faux.
• En gros, cela renvoie la valeur booléenne opposée de l'évaluation de son opérande. Pour
exemple :
!(5 == 5) // évalue à faux car l'expression à sa droite (5 == 5) est vraie.
!(6 <= 4) // évalue à vrai parce que (6 <= 4) serait faux.
!vrai // évalue à faux
!faux // évalue à vrai.

• Les opérateurs logiques && et || sont utilisés lors de l'évaluation de deux expressions pour obtenir
un seul résultat relationnel.
• L'opérateur && correspond à l'opération logique booléenne ET.
• Cette opération renvoie vrai si ses deux opérandes sont vrais, et faux sinon.
• Le panneau suivant montre le résultat de l'opérateur && évaluant l'expression a &&
b:

&& OPÉRATEUR

un b a && b
vrai vrai Vrai
true false False
false true False
faux faux Faux
• L'opérateur || correspond à l'opération logique booléenne OU.
• Cette opération renvoie vrai si l'un de ses deux opérandes est vrai, étant ainsi faux.
uniquement lorsque les deux opérandes sont eux-mêmes faux.
• Voici les résultats possibles de a || b :

|| OPÉRATEUR

Un B a || b
Vrai vrai vrai
Vrai faux vrai
false true true
faux faux faux
Classe : [Link](I.T) SEM - IV Sujet : Java de base

Par exemple :
( (5 == 5) && (3 > 6) ) // évalue à faux ( vrai && faux ).
( (5 == 5) || (3 > 6) ) // évalue à vrai ( vrai || faux ).

Opérateur conditionnel (: ? )
• L'opérateur conditionnel évalue une expression renvoyant une valeur si cela
l'expression est vraie et une différente si l'expression est évaluée comme fausse. Son format est :
condition ? résultat1 : résultat2
Si la condition est vraie, l'expression renverra résultat1, si ce n'est pas le cas, elle renverra résultat2.
7==5 ? 4 : 3 // renvoie 3, puisque 7 n'est pas égal à 5.
7==5+2 ? 4 : 3 // retourne 4, puisque 7 est égal à 5+2.
5>3 ? a : b // retourne la valeur de a, puisque 5 est supérieur à 3.
a > b ? a : b renvoie celui qui est le plus grand, a ou b. // opérateur conditionnel
Exemple :
classe ConditionalOpt
{
public static void main(String args[])
{
int n1 = 5;
int n2 = 3;

int ans = n1 > n2 ? n1 : n2;

[Link]("Nombre supérieur=" +ans);

}
}
o/p :Greater Number= 5

Opérateur virgule ( , )
• L'opérateur virgule (,) est utilisé pour séparer deux ou plusieurs expressions qui sont
inclus là où une seule expression est attendue.
• Lorsque l'ensemble des expressions doit être évalué pour une valeur, seul le plus à droite
l'expression est considérée.
Par exemple, le code suivant :
a = (b=3, b+2);

• D'abord, assigner la valeur 3 à b, puis assigner b+2 à la variable a. Donc, à la fin,

la variable a contiendrait la valeur 5 tandis que la variable b contiendrait la valeur 3.
Classe : [Link](I.T) SEM - IV Objet : Java de base

Opérateurs bitwise ( &, |, ^, ~, <<, >> )

• Le byte est le niveau le plus bas auquel nous pouvons accéder aux données
• Les opérateurs bit à bit modifient les variables en tenant compte des motifs de bits qui représentent le
valeurs qu'ils stockent.
équivalent asm de description
l'opérateur
& ET Bitwise ET
| OU Bitwise Inclusif
^ XOR OU exclusif bit à bit
~ NON Complément unaire (inversion de bits)

ET binaire

• L'opérateur AND bit à bit est un seul esperluette : &.

• Un moyen mnémotechnique pratique est que la version courte du ET booléen, &&, fonctionne sur
petits morceaux (bits au lieu de bytes, caractères, entiers, etc.).
• Un AND binaire prend simplement le AND logique des bits à chaque position d'un nombre
sous forme binaire.
Par exemple, travailler avec un octet (le type char) :
01001000 &
10111000 =
--------
00001000
Le bit le plus significatif du premier nombre est 0, donc nous savons que le bit le plus significatif du
le résultat doit être 0 ; dans le deuxième bit le plus significatif, le bit du deuxième nombre est zéro, donc nous
ont le même résultat. La seule fois où les deux bits sont 1, qui est la seule fois où le résultat
sera 1, est le cinquième bit à partir de la gauche. Par conséquent,
72 et 184 = 8

OU binaire
• L'OR bit à bit fonctionne presque de la même manière que l'AND bit à bit.
• La seule différence est que seulement un des deux bits doit être un 1 pour la position.
bit in the result to be 1. (If both bits are a 1, the result will also have a 1 in that position.)
• Le symbole est un tuyau : |. Encore une fois, cela ressemble à l'opérateur logique booléen, qui est ||.
01001000
10111000 =
--------
11111000
et par conséquent
Classe : [Link](I.T) SEM - IV Sujet : Java de base

72 | 184 = 248
Le Complément Bit à Bit
• L'opérateur de complément bit à bit, le tilde, ~, inverse chaque bit.
• Une façon utile de se souvenir de cela est que le tilde est parfois appelé un 'twiddle', et
le complément bit à bit inverse chaque bit : si vous avez un 1, c'est un 0, et si vous avez un 0, c'est un
1.
• Cela s'avère être un excellent moyen de trouver la plus grande valeur possible pour un non signé
number:
unsigned int max = ~0;
Opération binaire exclusive ou (XOR)
• Il n'y a pas d'opérateur booléen correspondant à l'exclusive-or bitwise, mais il y en a un
explication simple.
• L'opération exclusif ou prend deux entrées et retourne un 1 si l'une ou l'autre des deux
l'autre des entrées est un 1, mais pas si les deux le sont.
• C'est-à-dire que si les deux entrées sont 1 ou les deux entrées sont 0, cela retourne 0. L'opération binaire exclusive ou,

avec l'opérateur d'une carotte, ^, effectue l'opération exclusif-or sur chaque paire de bits.
L'exclusif ou est couramment abrégé en XOR.
• Par exemple, si vous avez deux nombres représentés en binaire comme 10101010 et
01110010 puis en appliquant l'opération XOR bit à bit, on obtient 11011000. C'est plus facile de le voir si les bits
sont alignés correctement :
01110010 ^
10101010
--------
11011000

Example
classe BitwiseOpt
{
public static void main(String args[])
{

int n1 = 110;
int n2 = 101;
[Link](n1 & n2);
[Link](n1 | n2);
[Link](~n2);
[Link](n1 ^ n2);

}
}
o/p:100 111 010 011
Classe : [Link](I.T) SEM - IV Sujet : Java de base

Opérateur de conversion de type

• Les opérateurs de conversion de type vous permettent de convertir une donnée d'un type donné à un autre.
• Il existe plusieurs façons de le faire en JAVA.
• Le plus simple, qui a été hérité du langage C, est de précéder le
expression à convertir par le nouveau type entre parenthèses (()):
int i;
float f = 3.14;
i = (int) f;
• Le code précédent convertit le nombre flottant 3,14 en une valeur entière (3), le
le reste est perdu. Ici, l'opérateur de conversion de type était (int).
• Une autre façon de faire la même chose en JAVA est d'utiliser la notation fonctionnelle :
précédant l'expression à convertir par le type et englobant l'expression
entre parenthèses :
i = int ( f );

Les deux méthodes de conversion de type sont valides en Java.

Classe : [Link](I.T) SEM - IV Sujet : Java de base

3 - Instructions de contrôle

L'instruction if

• Comme la plupart des langages, JAVA utilise le mot-clé si pour mettre en œuvre le contrôle de décision
instruction.
• La forme générale de l'instruction if ressemble à ceci :
si(conditions)
{
//corps des déclarations;

}
• Le mot-clé if indique au compilateur que ce qui suit est une instruction de contrôle de décision.
• La condition suivant le mot-clé si est toujours enfermée entre une paire de
parenthèses.
• Si la condition, quelle qu'elle soit, est vraie, alors l'instruction est exécutée.
• Si la condition n'est pas vraie, alors l'instruction n'est pas exécutée ; à la place, le programme
le dépasse.
L'expression est vraie si
x == y x est égal à y
x != y x n'est pas égal à y
x < y x est inférieur à y
x > y x est supérieur à y
x <= y x est inférieur ou égal à y
x >= y x est supérieur ou égal à y
déclaration-x
Classe : [Link](I.T) SEM - IV Sujet : Java de base

Exemple :

classe SimpleIf
{
public static void main(String args[])
{
int num = [Link](args[0]);

si(num >= 10 && num <= 100)

{
[Link]("Le nombre est compris entre 10 et 100");
}

}
}

L'instruction if-else

• L'instruction if à elle seule exécutera une seule instruction, ou un groupe d'instructions,

lorsque l'expression suivant 'si' évalue à vrai. Cela ne fait rien lorsque l'expression
évalue à faux.
si(condition)
{
//corps de l'instruction if;
}

sinon
{
// corps de l'instruction else ;
}
Classe : [Link](I.T) SEM - IV Subject : Core Java

Exemple :

classe IfElseDemo
{
public static void main(String args[])
{
int num = [Link](args[0]);

int r = num % 2;

si(r == 0)
{
[Link]("Nombre Pair");
}
sinon
{
[Link]("Nombre impair");
}
}
}

Instruction if else imbriquée :

L'instruction if-else permet de faire un choix entre deux alternatives possibles.

Parfois, un choix doit être fait entre plus de deux possibilités. Pour
par exemple, la fonction signe en mathématiques retourne -1 si l'argument est inférieur à
zéro, renvoie +1 si l'argument est supérieur à zéro et renvoie zéro si le
l'argument est zéro. La déclaration JAVA suivante implémente cette fonction :
Classe : [Link](I.T) SEM - IV Sujet : Java de base

si (x < 0)
sign = -1;
sinon
si (x == 0)
signe = 0;
sinon
sign = 1;
Ceci est une instruction if-else dans laquelle l'instruction suivant le else est elle-même un if-
instruction else.
Si x est inférieur à zéro, alors le signe est fixé à -1,
cependant, s'il n'est pas inférieur à zéro, l'instruction suivant le else est exécutée. Dans
Dans ce cas, si x est égal à zéro, alors le signe est égal à zéro et sinon il est égal à 1.
Lors de l'écriture d'instructions if-else imbriquées pour choisir entre plusieurs alternatives, utilisez un peu de
mise en page cohérente telle que suit :
si ( condition1 )
statement1 ;
sinon si ( condition2 )
déclaration2 ;
...
sinon si ( condition-n )
statement-n ;
sinon
déclaration-e ;

Exemple :

classe NestedIfDemo
{
public static void main(String args[])
{
int n1 = [Link](args[0]);
int n2 = [Link](args[1]);
Classe : [Link](I.T) SEM - IV Sujet : Java de base

int n3 = [Link](args[2]);

si(n1 < n2 || n1 < n3)

{
si(n2 > n3)
{
[Link]("n2 est plus grand");
}
sinon
{
[Link]("n3 est plus grand");
}
}
sinon
{
[Link]("n1 est plus grand");
}
}
}

Pause : -

• L'instruction break met fin à l'exécution de la boucle ou de la condition englobante la plus proche.
déclaration dans laquelle il apparaît.
• Le contrôle passe à l'instruction qui suit l'instruction terminée, le cas échéant.
pause;

• L'instruction break est utilisée avec l'instruction conditionnelle switch et avec le do,
pour et tant que déclarations de boucle.

• Dans une instruction switch, l'instruction break fait en sorte que le programme exécute le suivant
déclaration après l'instruction switch. Sans une instruction break, chaque déclaration à partir de
le label de cas apparié à la fin de l'instruction switch, y compris la clause par défaut, est
executed.
• Dans les boucles, l'instruction break met fin à l'exécution du do, for ou le plus proche englobant.
Instruction while. Le contrôle passe à l'instruction qui suit l'instruction terminée, le cas échéant.
• Dans les instructions imbriquées, l'instruction break met fin uniquement au do, for, switch, ou
une instruction while qui l'enferme immédiatement. Vous pouvez utiliser une instruction return ou goto pour
transférer le contrôle depuis des structures plus profondément imbriquées.
Classe : [Link](I.T) SEM - IV Sujet : Java de base

Continuer :

L'instruction continue transfère le contrôle à l'itération suivante de la boucle do ou for la plus proche,
ou instruction while dans laquelle elle apparaît, en contournant toutes les instructions restantes dans le do, for,
ou corps de l'instruction while.
Syntaxe
jump-statement:
continuer;
La prochaine itération d'une instruction do, for ou while est déterminée comme suit :
• Dans une instruction do ou while, la prochaine itération commence par réévaluer le
expression de l'instruction do ou while.
• Une instruction continue dans une instruction for provoque la première expression de la for
déclaration à évaluer. Ensuite, le compilateur réévalue l'expression conditionnelle et,
en fonction du résultat, soit termine soit itère le corps de l'instruction. Voir Le pour
Déclaration pour plus d'informations sur l'instruction for et ses non-terminaux.

Ceci est un exemple de l'instruction continue :

tandis que ( i-- > 0 )
{
x = f( i );
si ( x == 1 )
continuer;
y += x * x;
}

Instructions Switch
• Vous avez vu comment écrire des instructions if et if/else.
• Cela peut devenir assez déroutant lorsqu'ils sont imbriqués trop profondément, et JAVA offre un
alternative.
• Contrairement à if, qui évalue une seule valeur, les instructions switch vous permettent de diverger sur n'importe quel

d'un certain nombre de valeurs différentes.

• La forme générale de l'instruction switch est :
switch (option)
{
cas valeurUn : déclaration
Classe : [Link](I.T) SEM - IV Sujet : Java de base

pause;
cas valeurDeux :
déclaration;
pause;
....
cas valeurN :
déclaration;
pause;
default:
déclaration
pause;
}

• l'option est toute expression JAVA légale, et les déclarations sont toute JAVA légale.
instructions ou bloc d'instructions.
• switch évalue l'expression et compare le résultat à chacune des valeurs des cas.
Notez cependant que l'évaluation n'est que pour l'égalité ; les opérateurs relationnels peuvent ne pas être
ni utilisé ici, ni les opérations booléennes.
• Si l'une des valeurs de cas correspond à l'expression, l'exécution passe à celle-ci.
les instructions et continue jusqu'à la fin du bloc switch, sauf si une instruction break est
rencontré.
• Si rien ne correspond, l'exécution se dirige vers l'instruction par défaut facultative.
• S'il n'y a pas de défaut et qu'il n'y a pas de valeur correspondante, l'exécution continue.
instruction switch et l'instruction se termine.
Classe : [Link](I.T) SEM - IV Sujet : Java de base

4 - Boucles en JAVA

Types de boucles.

(a) En utilisant une déclaration for

(b) Utiliser une instruction while
(c) Utilisation d'une instruction do-while
Boucle tant que :-
Une boucle while fait en sorte que votre programme répète une séquence d'instructions tant que le
la condition de départ reste vraie.
syntaxe :
initialisation
tant que(condition)
{
//Corps de la boucle while;
//Incrément/Décrément;
}
1- Initialisation (opérateur d'assignement "=")
2- Condition (Opérateur relationnel)
3- Incrément/Décrément (Opérateurs d'incrément et de décrément "++" et "--")

Exemple :

classe WhileDemo
{
Classe : [Link](I.T) SEM - IV Subject : Core Java

public static void main(String[] args)

{
int i=1;

tant que(i <= 10)

{
[Link](i + "\t");
i++;
}

int j=10;
[Link]();
tandis que(j >= 1)
{

[Link](j+" ");
j--;
}
}
}

Boucle Do-While :
initialisation;
faire
{
//corps de la boucle do-while;
Incrément/Décrément
}tandis que(condition);

1- Initialisation (opérateur d'affectation "=")

2- Condition (Opérateur Relationnel)
3- Incrément/Décrément (L'opérateur d'incrément et de décrément "++" et "--")
Classe : [Link](I.T) SEM - IV Objet : Core Java

par exemple
int i=1;
faire
{
[Link](i);
i++;
}tant que(i<=10);

Différence entre la boucle while et la boucle do...while ?

Boucle Tant Que Boucle Do..While

La boucle while est déclarée avec le mot-clé while. La boucle Do While est déclarée avec do et while
mot-clé.
La boucle while teste d'abord la condition et ensuite La boucle do while exécute d'abord le corps de la boucle
exécute le corps de la boucle. and then test the condition.
Dans une boucle while, si la condition est fausse pour le premier Dans une boucle do while, si la condition est fausse pour la première fois
Le temps sera alors la boucle sera terminée. le temps que la boucle s'exécute au moins une fois.
Ceci est une boucle contrôlée par l'entrée. Cette boucle contrôlée par la sortie.

Syntaxe : Syntaxe :
initialisation; initialisation;
tant que(condition) faire
{ {
//Corps de la boucle while; //corps de la boucle do-while;
Incrément/Décrément Incrément/Décrément
} }tant que(condition);

Exemple : Exemple :
int i=1;
int i=1; fair
{
tandis que(i <= 10) [Link](i);
{ i++;
[Link](i + "\t"); }pendant(i<=10);
i++;
}
Classe : [Link](I.T) SEM - IV Subject : Core Java

Pour boucle :-

La boucle for est utilisée pour exécuter la même séquence d'instructions pour un nombre prédéterminé.
de fois. La forme générale de la boucle for est : -
Syntex:-
pour(initialisation;condition;incrément/décrément)
{
//corps de la boucle for;
}
1- Initialisation (Opérateur d'affectation "=")
2- Condition (Opérateur Relationnel)
3- Incrément/Décrément (Opérateurs d'incrémentation et de décrémentation "++" et "--")
Classe : [Link](I.T) SEM - IV Sujet : Java de base

Exemple :-
pour(int i=1;i<=10;i++)
{
[Link](i);
}

Liste des programmes

Écrivez un programme pour trouver le factoriel du nombre saisi par l'utilisateur ?

classe FactDemo
{
public static void main(String args[])
{
int num = [Link](args[0]);

int fact = 1; // Remarque

tant que(num > 0)

{
fact = fact * num;
num--;
Classe : [Link](I.T) SEM - IV Sujet : Java de base

/*

pour(int i=1;i<=num;i++)
{
fact = fact * i;
}

*/

/*

pour(int j=num;j>0;j--)
{
fait = fait * j;
}

*/

[Link]("Factorielle="+fact);
}
}

Programme pour trouver la série des factorielles entre 1 et 10 ?

classe FactDemoSérie
{
public static void main(String args[])
{

int num = [Link](args[0]);

pour(int i=1;i<=num;i++)
{

int fact = 1;
pour(int j=1;j<=i;j++)
{
fact = fact * j;
Classe : [Link](I.T) SEM - IV Subject : Core Java

}
[Link](i + " " + fact + " ");
}
}
}

Programme pour vérifier si le nombre saisi est un palindrome ou non ?

classe PallindromeDemo
{
public static void main(String args[])
{
int num = [Link](args[0]);
int temp = num;
int rev = 0;

tant que(num > 0)

{
int r = num % 10;
rev = (rev * 10) + r;
num = num / 10;
}
[Link]("Inverse="+rev);
si(rev == temp)
{
Systè[Link]("Nombre Palindrome");
}
sinon
{
[Link]("Pas un palindrome");
}

}
Class : [Link](I.T) SEM - IV Sujet : Java de base

WAP pour afficher la série de nombres premiers entre 1 et 100 ?

classe PrimeDemoSérie
{
public static void main(String args[])
{
int num = [Link](args[0]);

for(int i=1;i<=num;i++)
{
int count = 0; // Remarque
pour(int j=2;j<i;j++)
{
si(i%j == 0)
{
count++;
pause;
}
}
si(compte == 0)
{
[Link](i+" ");
}

}
}
Classe : [Link](I.T) SEM - IV Sujet : Java de base

Écrivez un programme pour vérifier si le nombre saisi est un nombre d'Armstrong ou non ?

classe ArmstrongDemo
{
public static void main(String args[])
{
int num = [Link](args[0]);
int temp= num;
int somme=0;
tant que(num > 0)
{
int r = num % 10;

somme = somme + (r*r*r);

num = num / 10;

}

si(somme == temp)
{
[Link]("Nombre d'Armstrong");
}
sinon
{
[Link]("Pas un nombre d'Armstrong");
}

}
}

WAP pour générer la série de Fibonacci entre 0 et la plage saisie par l'utilisateur ?
classe FibDemo
{
Classe : [Link](I.T) SEM - IV Objet : Java de base

public static void main(String args[])

{

int num = [Link](args[0]);

int f = 0;

int s = 1;

[Link](f+" ");
[Link](s+" ");

pour(int i=3;;i++)
{

int suivant = f + s;
si(next > num)
{
pause;
}
autre
{

[Link](next + " ");

f = s;
s = suivant;
}
}
}

}
Classe : [Link](I.T) SEM - IV Sujet : Java de base

/*

WAP pour imprimer

*
**
***
****
*****

*/
classe Patter1
{
public static void main(String args[])
{
pour(int i=1;i<=10;i++)
{
pour(int j=1;j<=10;j++)
{

[Link]("*" + " ");

}
[Link]();
}
}

/*
Programme pour imprimer

*****
****
***
**
*
Classe : [Link](I.T) SEM - IV Sujet : Java de base

*/

classe Patter2
{
public static void main(String args[])
{
pour(int i=5;i>0;i--)
{
pour(int j=1;j<=i;j++)
{
[Link]("*"+" ");
}

[Link]();
}
}
}

/*
Programme pour imprimer

1
23
456
7 8 9 10
11 12 13 14 15

*/

classe Patter3
{
public static void main(String args[])
{

int a=1;
pour(int i=1;i<=5;i++)
{
pour(int j=1;j<=i;j++)
{
[Link](a +" ");
a++;
}
[Link]();
}
}
}

/*
Programme pour imprimer
Classe : [Link](I.T) SEM - IV Objet : Java de base

1
01
010
1010
10101
*/
classe Patter4
{
public static void main(String args[])
{

int a=1;
pour(int i=1;i<=5;i++)
{
pour(int j=1;j<=i;j++)
{

[Link](a + " ");

a = a * (-1) + 1;

}
[Link]();
}
}
}

/*
WAP pour imprimer
*****
****
***
**
*
*/

classe Patter5
{
public static void main(String args[])
{
pour(int i=1;i<=5;i++)
{
pour(int j=1;j<i;j++)
{
[Link](" ");
}
pour(int k=i;k<=5;k++)
{
[Link]("*"+" ");
}
Classe : [Link](I.T) SEM - IV Sujet : Java de base

[Link]();
}
}
}

/*

WAP pour imprimer

*****
*****
*****
*****
*****

*/

class Patter1
{
public static void main(String args[])
{
pour(int i=1;i<=10;i++)
{
pour(int j=1;j<=10;j++)
{

[Link]("*" + " ");

}
[Link]();
}
}

/* Programme pour calculer les racines de l'équation quadratique */

classe Racinesquad
Classe : [Link](I.T) SEM - IV Subject : Core Java

{
public static void main(String args[])
{
double a, b, c, d, e ;
double temp , r1 , r2 ;
int sélectionner ;
a=2;b=3;c=6;
temp = (b * b) - (4 * a * c) ;
si (temp > 0)
sélectionner = 0 ;
sinon
si (temp == 0)
sélectionner = 1 ;
sinon
select = 2 ;
commutateur (sélectionner)

{
cas 0 :
temp = [Link](temp) ;
r1 = (-b + temp) / (2 * a) ;
r2 = (-b - temp) / (2 * a) ;
[Link]("The roots are Real and Unequal.\n");
[Link]("Les racines sont : " + r1 + " " + r2);
pause ;
cas 1 :
r1 = -b / (2 * a) ;
r2 = r1 ;
[Link]("Les racines sont réelles et égales.\n");
[Link]("The roots are : "+r1+" "+r2);
break ;
cas 2 :
temp = -temp ;
temp = [Link](temp) ;
temp = temp / (2 * a) ;
r1 = -b / (2 * a) ;
[Link]("Les racines sont réelles et imaginaires.\n");
[Link]("Les racines sont : " + r1 + " + j" + temp + " , " + r1 + " - j" + temp);
pause ;
}

}
}

/*
programme pour imprimer
A B C D C B A
Un B C B A
A B A
A
Classe : [Link](I.T) SEM - IV Objet : Java de base

*/
classe Modèle
{
public static void main(String args[])
{
int i=0,j=6,k=0;
char x='A';

tant que((j/2)>=0)
{
pour(i=0;i<=(j/2);i++)
[Link](" "+((char)(x+i)));
i=i-2;
pour(;i>=0;i--)
[Link](" "+((char)(x+i)));
j=j-2;
k=k+1;

pour(i=0;i<=k;i++)
[Link](" ");
}
}
}

Écrire un programme pour accepter un nombre de l'utilisateur et vérifier s'il est premier ou non ?

class PrimeDemo
{
public static void main(String args[])
{
int num = [Link](args[0]);

int compteur = 0;

for(int i=2;i<=num/2;i++)
{
si(num % i == 0)
{
compte++;
pause;
}
}
si(compte == 0)
{
[Link]("Nombre premier");
}
sinon
{
Classe : [Link](I.T) SEM - IV Sujet : Java de base

[Link]("Pas un nombre premier");

}

Écrivez un programme pour accepter un nombre de l'utilisateur et trouver l'inverse de ce nombre.

classe Reverse
{
public static void main(String args[])
{
int intNum = [Link](args[0]);

int intTemp = intNum;

int rev = 0;

/*

***** Première Logique *****

for(;intNum>0;)
Classe : [Link](I.T) SEM - IV Sujet : Java de base

{
int r = intNum % 10;

rev = rev * 10 + r;

intNum = intNum / 10;

}

*/

// ***** Première logique *****

tant que(intNum > 0)

{
int r = intNum % 10;

rev = rev * 10 + r;

intNum = intNum / 10;

}

[Link]("Reverse =" +rev);

}

}
Classe : [Link](I.T) SEM - IV Sujet : Core Java
Classe : [Link](I.T) SEM - IV Sujet : Java de base

6- Tableaux et chaînes

Tableaux

Un tableau est une structure de données consistant en une liste numérotée d'éléments, où tous les éléments sont
du même type.
Un tableau est une collection de données similaires avec le même nom...
Un tableau est un type de données de référence défini par l'utilisateur...
En Java, les éléments d'un tableau sont toujours numérotés de zéro jusqu'à un certain maximum
valeur, qui est définie lorsque le tableau est créé. Par exemple, un tableau pourrait contenir 10
entiers, numérotés de zéro à 9.
Les éléments d'un tableau peuvent appartenir à l'un des types primitifs de Java. Ils peuvent également être
références aux objets.
La longueur d'un tableau est établie lors de la création du tableau. Après sa création, sa longueur est
fixé.

Un tableau de dix éléments

Chaque élément d'un tableau est appelé un élément, et chaque élément est accessible par son numéro.
index.
Comme indiqué dans l'illustration ci-dessus, la numérotation commence à 0. Le 9ème élément, pour
L'exemple serait donc accessible à l'index 8.
Syntaxe :

DataType Name OfArray[];

ArrayName = nouveau DataType[Size];
OU
DataType NomDuTableau[] = new DataTypeTaille;

TypeDeDonnées: Détermine le type de la valeur que le tableau doit stocker (int, float, etc.)
Classe : [Link](I.T) SEM - IV Subject : Core Java

NameOfArray is any user defined name.

La taille détermine la valeur maximale que le tableau peut stocker.
Le nouvel opérateur est utilisé pour allouer de la mémoire pour les éléments du tableau.

Exemple :
int num[];
num = nouveau int[5];
OU
int num[] = new int[5];

Étapes :
1) Déclaration d'un tableau.
2) Initialisation d'un tableau.
3) Affichage des éléments du tableau.

1) Déclaration d'un tableau.

Cette étape est réalisée en utilisant la syntaxe comme suit.

TypeDeDonnées NomDuTableau[];
ArrayName = nouveau DataType[Size];
OU
DataType NomDuTableau[] = new DataTypeTaille;
TypeDeDonnées : Détermine le type de la valeur que le tableau doit stocker (int,float etc)
NameOfArray est un nom défini par l'utilisateur.
La taille détermine la valeur maximale que le tableau peut stocker.
L'opérateur new est utilisé pour allouer de la mémoire pour les éléments de tableau.

Exemple :
int num[];
num = nouveau int[5];
OU
int num[] = new int[5];

Initialisation d'un tableau.

Cette étape est réalisée en utilisant l'opérateur d'affectation.

int num[] = new int[5];

num[0] = 1;
num[1] = 2;
num[2] = 3;
num[3] = 11;
num[4] = 33;
Classe : [Link](I.T) SEM - IV Sujet : Java de base

// Deuxième façon

int num[] = {1,2,3,4,5,6,7,8,9,44,33,2,323};

Créer, initialiser et accéder à un tableau

Une façon de créer un tableau est avec l'opérateur new.

La déclaration suivante dans le programme ArrayDemo alloue un tableau avec suffisamment de mémoire
pour dix éléments entiers et assigne le tableau à la variable anArray.
anArray = new int[10]; // créer un tableau d'entiers

Si cette déclaration était manquante, le compilateur afficherait une erreur comme suit, et
la compilation échouerait :

[Link]: La variable anArray n'a peut-être pas été initialisée.

Les prochaines lignes attribuent des valeurs à chaque élément du tableau :

anArray[0] = 100; // initialize first element
anArray[1] = 200; // initialize second element
anArray[2] = 300; // etc.
Chaque élément du tableau est accessible par son index numérique :
[Link]("Élément 1 à l'index 0 : " + anArray[0]);
[Link]("Élément 2 à l'index 1 : " + anArray[1]);
[Link]("Élément 3 à l'index 2 : " + anArray[2]);
Alternativement, vous pouvez utiliser la syntaxe abrégée pour créer et initialiser un tableau :
int[] unTableau = {100, 200, 300, 400, 500, 600, 700, 800, 900, 1000};
Ici, la longueur du tableau est déterminée par le nombre de valeurs fournies
entre{et}.

classe Tableau1
{
public static void main(String args[])
{
/*
int num[] = new int[5];
num[0] = 1;
num[1] = 2;
num[2] = 3;
num[3] = 11;
num[4] = 33;

*/

// OU
Classe : [Link](I.T) SEM - IV Subject : Core Java

int num[] = {1,2,3,4,5,6,7,8,9,44,33,2,323};

int len = [Link];

[Link]("Longueur="+len);

pour(int i=0;i<[Link];i++)
{
[Link]("Indice du tableau " + i + " " + num[i] );
}
}
}

Tableau bi-dimensionnel ou double dimension

Lorsque la déclaration d'un tableau utilise deux indices pour déclarer un tableau, il est appelé
tableau à deux dimensions ou double dimension

Ce type de tableau est utilisé pour imprimer ou manipuler la structure matricielle.

Il définit le nombre de lignes et de colonnes comme sa taille.

Syntaxe :
TypeDeDonnées NomDuTableau[][];
NomDuTableau = nouveau TypeDeDonnées[Size1][size2];
Classe : [Link](I.T) SEM - IV Objet : Java de base

OU

DataType NomDuTableau[][] = nouveau DataType[taille1][taille2];

Où
Le type de données détermine le type de la valeur que le tableau stocke (int, float, double, etc.).
NameOfArray est un nom défini par l'utilisateur.
l'opérateur new est utilisé pour allouer de la mémoire pour les éléments du tableau.

Size1 refers to the rows.

Size2 fait référence aux colonnes.

En interne, Java stocke les tableaux à deux dimensions sous forme de tableau de tableaux :

Exemple :

int num[][] = new int[3][3];

int num1[][] = new int[3][2];
How to use 2-Dimensional Array:

1) Déclaration d'un tableau à deux dimensions.

2) Création de la mémoire
3)Affichage des éléments d'un tableau.

/*
Tableau à deux dimensions :
lorsque la déclaration de tableau utilise deux indices pour déclarer un tableau, on l'appelle deux
tableau multidimensionnel...
datatype[][] NomDuTableau = new datatype[taille][taille1];
int[][] intNum = new int[2][2];
*/
classe Tableau2D
{
Classe : [Link](I.T) SEM - IV Sujet : Java de base

public static void main(String args[])

{
//int[][] intNum = new int[2][2]; //Déclaration de tableau...

// Création d'un tableau

/*
intNum[0][0] = 3;
intNum[0][1] = 3;
intNum[1][0] = 3;
intNum[1][1] = 3;
*/

int[][] intNum = {

{3,3,5}
{4,5,6}
{4,5,6}
};

pour(int i=0;i<[Link];i++)
{
pour(int j=0;j<[Link];j++)
{
[Link](intNum[i][j]+" ");
}
[Link]();
}

}
}

Entrée de tableau à deux dimensions :

importer [Link].*;
Classe : [Link](I.T) SEM - IV Sujet : Java de base

classe DeuxDArrayUserInput
{
public static void main(String args[]) throws IOException
{
int[][] intNum = new int[2][2]; //Déclaration du tableau...

BufferedReader br = new BufferedReader(new InputStreamReader([Link])) ;

[Link]("Entrez les éléments de la matrice=");

pour(int i=0;i<[Link];i++)
{
pour(int j=0;j<[Link];j++)
{

intNum[i][j] = [Link]([Link]());
}
}

pour(int i=0;i<[Link];i++)
{
for(int j=0;j<[Link];j++)
{
[Link](intNum[i][j]+" ");
}
[Link]();
}
}
}

Addition de matrices :

importer [Link].*;
Classe : [Link](I.T) SEM - IV Subject : Core Java

classe AjouterMatrice
{
public static void main(String args[]) jette IOException
{
int[][] intNum1 = new int[2][2];

int[][] intNum2 = new int[2][2];

int[][] intSum = new int[2][2];

BufferedReader br = new BufferedReader(new InputStreamReader([Link])) ;

[Link]("Entrez les éléments de la première matrice=");

for(int i=0;i<[Link];i++)
{
pour(int j=0;j<[Link];j++)
{

intNum1[i][j] = [Link]([Link]());
}
}

[Link]("Entrez les éléments de la deuxième matrice=");

for(int i=0;i<[Link];i++)
{
for(int j=0;j<[Link];j++)
{

intNum2[i][j] = [Link]([Link]());
}
}
Systè[Link]("Première Matrice:");
pour(int i=0;i<[Link];i++)
{
pour(int j=0;j<[Link];j++)
{
[Link](intNum1[i][j]+" ");
}
[Link]();
}
Systè[Link]("Deuxième matrice :");
pour(int i=0;i<[Link];i++)
{
pour(int j=0;j<[Link];j++)
{
[Link](intNum2[i][j]+" ");
}
Classe : [Link](I.T) SEM - IV Subject : Core Java

[Link]();
}

pour(int i=0;i<[Link];i++)
{
for(int j=0;j<[Link];j++)
{
intSum[i][j] = intNum1[i][j] + intNum2[i][j];
}
}

Systè[Link]("Somme de la matrice :");

for(int i=0;i<[Link];i++)
{
for(int j=0;j<[Link];j++)
{
[Link](intSum[i][j]+" ");
}
[Link]();
}

}
}

Somme des éléments diagonaux de la matrice :

Classe : [Link](I.T) SEM - IV Sujet : Java de base

importer [Link].*;
classe SommeDeLaDiagonale
{
public static void main(String args[]) throws IOException
{
int[][] intNum1 = new int[2][2];

BufferedReader br = new BufferedReader(new InputStreamReader([Link])) ;

[Link]("Entrez les éléments de la première matrice=");

pour(int i=0;i<[Link];i++)
{
pour(int j=0;j<[Link];j++)
{

intNum1[i][j] = [Link]([Link]());
}
}

[Link]("Première Matrice:");
pour(int i=0;i<[Link];i++)
{
for(int j=0;j<[Link];j++)
{
[Link](intNum1[i][j]+" ");
}
[Link]();
}

int somme = 0;
pour(int i=0;i<[Link];i++)
{
for(int j=0;j<[Link];j++)
{
si(i == j)
{
somme = somme + intNum1[i][j];
}
}
}

[Link]("Somme des éléments diagonaux=" +sum);

Classe : [Link](I.T) SEM - IV Sujet : Java de base

Tableau multidimensionnel

Un tableau multidimensionnel de dimension n (c'est-à-dire un tableau n-dimensionnel ou simplement n-D)

un tableau) est une collection d'éléments qui est accessible par des expressions de souscription. Par exemple,

dans une langue qui le supporte, le l'élément du tableau bidimensionnel x est

accédé en écrivant x[i,j].
Vous pouvez également déclarer un tableau de tableaux (également connu sous le nom de tableau multidimensionnel) en
using two or more sets of square brackets, such as String[][] names. Each element,
par conséquent, doit être accessible par un nombre correspondant de valeurs d'index.
Dans le langage de programmation Java, un tableau multidimensionnel est simplement un tableau dont
les composants sont eux-mêmes des tableaux.
Ceci est différent des tableaux en C ou en Fortran. Une conséquence de cela est que les lignes sont autorisées à
varient en longueur, comme montré dans ce qui suitDémoMultiDimArrayogram:
classe MultiDimArrayDemo {
public static void main(String[] args) {
String[][] names = {{"Mr. ", "Mrs. ", "Ms. "},
{"Smith", "Jones"}};
[Link](names[0][0] + names[1][0]); //M. Smith
[Link](names[0][2] + names[1][1]); //Mme Jones
}
}
La sortie de ce programme est :
M. Smith
Mme Jones
Classe : [Link](I.T) SEM - IV Subject : Core Java

Enfin, vous pouvez utiliser la propriété length intégrée pour déterminer la taille de n'importe quel tableau.
code
[Link]([Link]);
affichera la taille du tableau à la sortie standard.

Comment prendre une entrée de l'utilisateur en utilisant un tableau ?

importer [Link].*;
classe ArrayInput
{

public static void main(String args[]) throws IOException

{
int intNum[] = new int[5];

BufferedReader br = new BufferedReader(new InputStreamReader([Link]));

[Link]("Entrez les éléments du tableau !!!");

pour(int i=0;i<[Link];i++)
{
intNum[i] = [Link]([Link]());
}

pour(int i=0;i<[Link];i++)
{
[Link]("Élément du tableau="+i+" "+intNum[i]);
}

}
Classe : [Link](I.T) SEM - IV Objet : Java de base

/*
Écrivez un programme pour accepter 10 nombres de l'utilisateur et trouver le plus grand des 10 nombres.
*/

import [Link].*;
classe Large5Num
{

public static void main(String args[])throws IOException

{
int intNum[] = new int[10];

BufferedReader br = new BufferedReader(new InputStreamReader([Link]));

[Link]("Enter The Array Elements !!!");

for(int i=0;i<[Link];i++)
{
intNum[i] = [Link]([Link]());
}

pour(int i=0;i<[Link];i++)
{
[Link]("Élément du tableau="+i+" "+intNum[i]);
}

int intLarge = intNum[0];

for(int i=1;i<[Link];i++)
{
si(intLarge < intNum[i])
{
intLarge = intNum[i];
}
}

[Link]("Plus grand nombre="+intLarge);

}
Classe : [Link](I.T) SEM - IV Subject : Core Java

Programme pour trier 5 nombres en utilisant le tri à bulles ?

import [Link].*;
classe TriBulles
{
public static void main(String args[]) throws IOException
{
int[] intNum = new int[5]; // Decleration Of Array

BufferedReader br = new BufferedReader(new InputStreamReader([Link])) ;

[Link]("Entrez les 5 nombres=");

pour(int i=0;i<[Link];i++)
{
intNum[i] = [Link]([Link]());
}
pour(int i=0;i<[Link];i++)
{
[Link](intNum[i] +" ");
}

pour(int i=0;i<[Link];i++)
{
pour(int j=i+1;j<[Link];j++)
{
Classe : [Link](I.T) SEM - IV Sujet : Java de base

si(intNum[i] < intNum[j])

{
int intTemp = intNum[i];
intNum[i] = intNum[j];
intNum[j] = intTemp;
}
}
}
[Link]();
[Link]("Les éléments triés sont :");
pour(int i=0;i<[Link];i++)
{
[Link](intNum[i] +" ");
}
}
}
Classe : [Link](I.T) SEM - IV Subject : Core Java

Chansons
LeStringla classe représente des chaînes de caractères. Tous les littéraux de chaîne dans les programmes Java, tels que
abc, sont mis en œuvre en tant qu'instances de cette classe.
Les chaînes sont constantes ; leurs valeurs ne peuvent pas être modifiées après leur création. Les tampons de chaînes
prendre en charge des chaînes mutables. Parce que les objets String sont immuables, ils peuvent être partagés. Pour
example:
chaîne str = "abc";
est équivalent à :
char data[] = {'a', 'b', 'c'};
String str = new String(data);

Voici quelques exemples supplémentaires de la façon dont les chaînes peuvent être utilisées :

[Link]("abc");
String cde = "cde";
[Link]("abc" + cde);
String c = "abc".substring(2,3);
String d = [Link](1, 2);

CONSTRUCTEURS
Chaîne() Initialise un nouvel objet String afin que
il représente une séquence de caractères vide.

Chaîne(car caractères[] ) Construit une nouvelle chaîne en décodant le

tableau d'octets spécifié en utilisant la plateforme
jeu de caractères par défaut.
Chaîne(caractères chars[], int indexDébut, int nbCaractères) Crée une chaîne avec un indice de départ et un nombre de
Personnages.
Chaîne(Objet chaîne) Crée la chaîne avec l'objet spécifié obj.

Méthodes :

charAt(int index)
Char Renvoie le caractère à l'index spécifié.
IntcompareÀ(Chaîne anotherString)
Compare deux chaînes de caractères lexicographiquement.

IntcomparerIgnorerCas(Chaîne str)
Compare deux chaînes de caractères lexicographiquement, en ignorant les différences de casse.

Address:- 1244/3 Shinde House, Barkat Ali Dargah Road, Wadala(E) Mumbai-37
Prof. Shahid Ansari(9821-77-1054)
Classe : [Link](I.T) SEM - IV Subject : Core Java

Chaineconcaténer(Chaîne str)
Concatène la chaîne spécifiée à la fin de cette chaîne.
BooléencontentEquals(StringBuffer sb)
Renvoie vrai si et seulement si cette chaîne représente la même séquence de
caractères comme le StringBuffer spécifié.
Booléense termine par(Chaîne ssuffixe)
Teste si cette chaîne se termine par le suffixe spécifié.
Booléenégal(Objet anObjet)
Compare cette chaîne à l'objet spécifié.
BooléenequalsIgnoreCase(Chaîne anotherString)
Compare cette chaîne à une autre chaîne, en ignorant les considérations de casse.

octet[]obtenirOctets()
Encodes this String into a sequence of bytes using the platform's default
jeu de caractères, stockant le résultat dans un nouveau tableau d'octets.

vide
getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin
Copie les caractères de cette chaîne dans le tableau de caractères de destination.

int longueur()
Renvoie la longueur de cette chaîne.

booléen matchs(String regex)

Indique si cette chaîne correspond ou non à celle donnéeexpression régulière.

Chaîne
remplacer(char ancienChar, char nouveauChar
Renvoie une nouvelle chaîne résultant du remplacement de toutes les occurrences de oldChar dans ceci
chaîne avec newChar.

Chaine remplacerTout(Chaîne regex,Chaîne replacement

Remplace chaque sous-chaîne de cette chaîne qui correspond au donnéexpression régulière
avec le remplacement donné.

Chaîne remplacerPremier(Chaîne regexChaîne rremplacement

Remplace le premier sous-texte de cette chaîne qui correspond au donnérégulier
expression wavec le remplacement donné.

Address:- 1244/3 Shinde House, Barkat Ali Dargah Road, Wadala(E) Mumbai-37
Prof. Shahid Ansari(9821-77-1054)
Classe : [Link](I.T) SEM - IV Sujet : Java de base

booléen commencePar(String prefix)

Tests if this string starts with the specified prefix.

booléen
commencePar(Chaîne prefix, int toffset)
Teste si cette chaîne commence par le préfixe spécifié à partir d'un index spécifié.

Chaîne sous-chaîne(int beginIndex, int endIndex)

Renvoie une nouvelle chaîne qui est un sous-ensemble de cette chaîne.

Chaîne
minuscules()
Convertit tous les caractères de cette chaîne en minuscules selon les règles de la
paramètre régional par défaut.

Chaîne toString()
Cet objet (qui est déjà une chaîne !) est lui-même renvoyé.

Chaîne
toUpperCase()
Convertit tous les caractères de cette chaîne en majuscules en utilisant les règles du
paramètre régional par défaut.

Chaîne
tailler()
Renvoie une copie de la chaîne, avec les espaces vides au début et à la fin omis.

Exemple :

classe StringDemo
{
public static void main(String args[])
{

Adresse :- 1244/3 Maison Shinde, Route Barkat Ali Dargah, Wadala(E) Mumbai-37
Prof. Shahid Ansari (9821-77-1054)
Classe : [Link](I.T) SEM - IV Sujet : Java de base

// ******* Constructeurs ******

String str = new String(); // Chaîne vide

str = "Juned";// assings junaid to str

char data[] = {'s','h', 'a','h','i','d'}; // Déclaration d'un tableau de caractères

String str1 = new String(data);// assigne data à str1

String str2 = "Ibrahim"; // assigne directement Ibrahim à str2

// Afficher toutes les chaînes déclarées...

[Link]("Str="+str);
[Link]("Str1="+str1);

[Link]("Str2="+str2);
[Link]("Str="+str);

// ****** Méthodes ******

[Link]([Link](1)); // donne le 2 caractère de str

[Link]([Link](4));// donne le 5ème caractère de str1

[Link]([Link](0));// donne la valeur unicode correspondante

[Link]([Link](str2)); // conpares two strings

[Link]([Link](str2)); // concaténer deux chaînes

[Link]([Link]("u")); // si str1 contient u alors retourne vrai

[Link]([Link](str2));// compare deux chaînes en ignorant la casse

[Link]([Link]());// renvoie la longueur de str1

[Link]([Link]('s', 'i')); // remplace s par i dans str

[Link]([Link]("shahid","Ibrahim"));// remplace shahid par ibrahim
de str1

[Link]([Link]()); // convertit en majuscules

[Link]([Link]()); // convertit en minuscules

String str5 = "s h a hid";

[Link]([Link]());
}
Classe : [Link](I.T) SEM - IV Subject : Core Java

Classe StringBuffer :

Un tampon de chaîne est comme une chaîne, mais peut être modifié.
À tout moment, il contient une séquence particulière de caractères, mais la longueur et
Le contenu de la séquence peut être modifié par certains appels de méthode.
Chaque tampon de chaîne a une capacité.
Tant que la longueur de la séquence de caractères contenue dans le tampon de chaîne ne
dépasser la capacité, il n'est pas nécessaire d'allouer un nouveau tableau tampon interne.
Si le tampon interne déborde, il est automatiquement agrandi.

Constructeurs:

StringBuffer()
Construit un tampon de chaîne sans caractères et une capacité initiale de 16 caractères.
StringBuffer(int longueur)
Construit un tampon de chaîne sans caractères et une capacité initiale spécifiée par le
argument de longueur.

Tampon de chaîne(Chaîne str)

Classe : [Link](I.T) SEM - IV Subject : Core Java

Construit un tampon de chaîne afin qu'il représente la même séquence de caractères que le
argument de chaîne ; en d'autres termes, le contenu initial du tampon de chaîne est une copie de la
chaîne d'argument

Méthodes
StringBufferappend(boolean b)
Ajoute la représentation sous forme de chaîne de l'argument booléen à la
séquence.
StringBufferajouter(char c)
Ajoute la représentation sous forme de chaîne de l'argument char à cette séquence.

StringBufferappend(char[] str)
Ajoute la représentation sous forme de chaîne du tableau de caractères en argument à ceci
séquence.
StringBufferappend(char[] str, int offset, int len)
Ajoute la représentation sous forme de chaîne d'un sous-tableau du tableau de caractères
argument à cette séquence.
StringBufferajoute(double d)
Ajoute la représentation sous forme de chaîne de l'argument double à ceci
séquence.
StringBufferappend(float f)
Ajoute la représentation sous forme de chaîne de l'argument float à cette séquence.

StringBufferappend(int i)
Ajoute la représentation sous forme de chaîne de l'argument entier à cette séquence.

StringBufferappend(long lng)
Ajoute la représentation sous forme de chaîne de l'argument long à cette séquence.

StringBufferappend(Object obj)
Ajoute la représentation sous forme de chaîne de l'argument Object.

StringBufferajouter(String str)
Ajoute la chaîne spécifiée à cette séquence de caractères.
StringBufferappend(StringBuffer sb)
Ajoute le StringBuffer spécifié à cette séquence.
StringBufferappendCodePoint(int codePoint)
Ajoute la représentation sous forme de chaîne de l'argument codePoint à ceci
séquence.
intcapacity()
Classe : [Link](I.T) SEM - IV Subject : Core Java

Renvoie la capacité actuelle.

charAt(int index)
Renvoie la valeur de caractère dans cette séquence à l'index spécifié.

intcodePointAt(int index)
Renvoie le caractère (point de code Unicode) à l'index spécifié.
StringBufferdelete(int début, int fin)
Supprime les caractères d'une sous-chaîne de cette séquence.
StringBufferdeleteCharAt(int index)
Supprime le caractère à la position spécifiée dans cette séquence.

StringBufferinsert(int offset, char c)

Insère la représentation sous forme de chaîne de l'argument char dans cette séquence.

StringBufferinsérer(int décalage, char[] str)

Insère la représentation sous forme de chaîne du tableau de caractères argument dans ceci
séquence.
StringBufferinsérer(int index, char[] str, int décalage, int longueur)
Insère la représentation sous forme de chaîne d'un sous-tableau de l'argument de tableau str
dans cette séquence.
intlength()
Retourne la longueur (nombre de caractères).

StringBufferremplacer(int start, int end, String str)

Remplace les caractères dans une sous-chaîne de cette séquence par des caractères dans
la chaîne spécifiée.
StringBufferreverse()
Fait que cette séquence de caractères soit remplacée par l'inverse de la
séquence.
Sous-chaîne(Entier début)
Renvoie une nouvelle chaîne qui contient une sous-séquence de caractères actuellement
contenu dans cette séquence de caractères.

Stringsubstring(int début, int fin)

Renvoie une nouvelle chaîne qui contient une sous-séquence de caractères actuellement
contenu dans cette séquence.
StringtoString()
Renvoie une chaîne représentant les données dans cette séquence.

voidtrimToSize()
Tentatives de réduire l'espace de stockage utilisé pour la séquence de caractères.
Classe : [Link](I.T) SEM - IV Sujet : Java de base

Exemple :

classe StringBufferDemo1
{
public static void main(String args[])
{

// ***** Constructeurs *****

StringBuffer sb = new StringBuffer();

StringBuffer sb1 = new StringBuffer(100);

StringBuffer sb3 = new StringBuffer("Shahid Ansari");

[Link]("String="+sb);
[Link]("Capacité="+[Link]());

[Link]("String="+sb1);
[Link]("Capacité="+[Link]());

[Link]("Chaîne="+sb3);
[Link]("Capacité="+[Link]());

// ******Méthodes******

Objet obj = new Objet();

obj = "ABCDEFGH".toString();

[Link](obj);
[Link]("Chaîne="+sb);
[Link]("Longueur de sb="+[Link]());
[Link]("Capacité="+[Link]());

StringBuffer sb5 = new StringBuffer();

[Link](123);
[Link]("Sb5="+sb5);
Classe : [Link](I.T) SEM - IV Sujet : Java de base

[Link]("Reverse="+[Link]());
[Link](2,8);
[Link]("Chaîne après suppression="+sb3);

StringBuffer sb6 = new StringBuffer("Amit ");

char[] données = {'B','h','t','t','e'};
[Link]érer(5,données);

[Link]("Après insertion="+sb6);
}
}

Copie des tableaux

La classe System a une méthode de copie de tableau que vous pouvez utiliser pour copier des données de manière efficace
d'un tableau à un autre :

public static void arraycopy(Object src,

int srcPos,
Objet dest,
int destPos,
int longueur)
The twoObjectarguments specify the array to copyfromand the array to copyto.
Les trois arguments spécifient la position de départ dans le tableau source, le début
position dans le tableau de destination, et le nombre d'éléments du tableau à copier.
Classe : [Link](I.T) SEM - IV Sujet : Java de base

Le programme suivant,ArrayCopyDemo, déclare un tableau d'éléments de caractères, épelant le

mot "décaféiné". Il utilise arraycopy pour copier une sous-séquence des composants du tableau dans un
deuxième tableau

class ArrayCopyDemo {
public static void main(String[] args) {
char[] copyFrom = { 'd', 'e', 'c', 'a', 'f', 'f', 'e',
'j', 'n', 'à', 't', 'é', 'd' }
char[] copyTo = new char[7];

[Link](copyFrom, 2, copyTo, 0, 7);

[Link](new String(copyTo));
}
}
La sortie de ce programme est :
caféine

Array of Objects
Un tableau 2D d'objets est un tableau d'un tableau de références à des objets :

// crée les numéros de référence uniques (carré jaune)

Tableau [][] carré;

// crée le tableau de références aux tableaux (carrés bleus)

plateau = nouveau Carré[2][];

// crée des tableaux de références à des objets (carrés rouges).

pour (int i=0; i < [Link] ; i++)
board[i] = new Square[3]; // créer des tableaux de références à
objets
Remarque : les instructions ci-dessus peuvent être combinées en l'instruction :
Carré [][] tableau = nouveau Carré[2][3];
Cependant, nous n'avons toujours pas créé d'objets ! Pour créer des objets, il n'y a pas de moyen simple autre que
que avec des boucles :
Classe : [Link](I.T) SEM - IV Sujet : Java de base

pour (int i=0; i < [Link] ; i++)

pour (int j=0; j < tableau[i].longueur ; j++)
board[i][j] = new Square(i,j,couleur);
Vecteur
Les vecteurs sont couramment utilisés à la place des tableaux, car ils s'étendent automatiquement quand
de nouvelles données leur sont ajoutées.
Les vecteurs ne peuvent contenir que des objets et non des types primitifs (par exemple, int).
Si vous souhaitez mettre un type primitif dans un Vector, placez-le à l'intérieur d'un objet (par exemple, pour enregistrer un)
valeur entière utilisez la classe Integer ou définissez votre propre classe).
Si vous utilisez l'enveloppe Integer, vous ne pourrez pas changer la valeur entière, donc il est
parfois utile de définir votre propre classe.
Créer un vecteur avec une taille initiale par défaut
Vecteur v = nouveau Vecteur();
Créer un vecteur avec une taille initiale
Vecteur v = nouveau Vecteur(300);
[Link](s); // ajoute s à la fin du Vector v
There are many useful methods in the Vector class and its parent classes. Here are some of the
le plus utile. vis un Vecteur, i est un index int, o est un Objet.
Méthode Description
[Link](o) ajoute l'objet o au vecteur v
[Link](i, o) Insère l'objet o à l'index i, décalant les éléments vers le haut si nécessaire.
[Link]() supprime tous les éléments du vecteur v
[Link](o) Renvoie vrai si le vecteur v contient l'objet o
Renvoie le premier élément.
[Link]Élément(i)
[Link](i) Renvoie l'objet à l'index entier i.
Retourne le dernier élément.
[Link]Élément(i)
Returns a ListIterator that can be used to go over the Vector. This is a
[Link]()
alternative utile à la boucle for.
Supprime l'élément à la position i, et décale tous les éléments suivants
[Link](i)
en bas.
[Link](i,o) Définit l'élément à l'index i sur o.
[Link]() Renvoie le nombre d'éléments dans le vecteur v.
Classe : [Link](I.T) SEM - IV Sujet : Java de base

7 - Gestion des exceptions

Le terme exception est un raccourci pour l'expression "événement exceptionnel."

Definition:Anexceptionis an event, which occurs during the execution of a program, that

perturbe le flux normal des instructions du programme.
Lorsqu'une erreur se produit dans une méthode, la méthode crée un objet et le remet à
le système d'exécution.
L'objet, appelé objet d'exception, contient des informations sur l'erreur, y compris son
type et l'état du programme lorsque l'erreur s'est produite.
Créer un objet d'exception et le remettre au système d'exécution s'appelle lancer une exception.
exception.
Après qu'une méthode a levé une exception, le système d'exécution tente de trouver quelque chose pour
gère-le.
L'ensemble des "quelque chose" possibles pour gérer l'exception est la liste ordonnée des méthodes.
qui avait été appelé pour accéder à la méthode où l'erreur s'est produite.
La liste des méthodes est connue sous le nom de pile d'appels (voir la figure suivante).

La pile d'appels.

Le système d'exécution recherche la pile d'appels pour une méthode qui contient un bloc de code qui
peut gérer l'exception. Ce bloc de code est appelé un gestionnaire d'exception.
La recherche commence par la méthode par laquelle l'erreur s'est produite et se poursuit à travers le
la pile d'appels dans l'ordre inverse dans lequel les méthodes ont été appelées.
Lorsque un gestionnaire approprié est trouvé, le système d'exécution passe l'exception au
manipulateur.
Un gestionnaire d'exceptions est considéré comme approprié si le type de l'objet d'exception levé
correspond au type qui peut être géré par le gestionnaire.
Le gestionnaire d'exceptions choisi est dit attraper l'exception.
Si le système d'exécution recherche de manière exhaustive toutes les méthodes sur la pile d'appels sans
trouver un gestionnaire d'exception approprié, comme montré dans la figure suivante, le système d'exécution
(et, par conséquent, le programme) se termine.
Classe : [Link](I.T) SEM - IV Subject : Core Java

Recherche de l'appel de pile pour le gestionnaire d'exceptions.

Utiliser des exceptions pour gérer les erreurs présente des avantages par rapport à la gestion traditionnelle des erreurs.
techniques.
Le code de programmation Java valide doit respecter l'exigence de Attraper ou Spécifier.
signifie que le code qui pourrait générer certaines exceptions doit être enfermé par l'un des
suivant :
Une déclaration try qui capture l'exception. Le try doit fournir un gestionnaire pour le
exception, comme décrit dansAttraper et gérer les exceptions.
Une méthode qui spécifie qu'elle peut lancer l'exception. La méthode doit fournir un
clause throws qui liste l'exception, comme décrit dansSpécification des exceptions
Lancé par une méthode.

LES MOTS CLÉS FINALEMENT :

"Enfin" crée un bloc de code qui sera exécuté après que le bloc try/catch a été complété
and before the code following the try/catch block.
Le finally est un mot-clé Java utilisé pour définir un bloc qui est toujours exécuté dans un
try−catch−finally statement. In java, there are three clauses named try, catch and finally
used as exception handler components. A finally block typically contains cleanup code
that recovers from partial execution of a try block.
essayer {
/ Chemin d'exécution normal
……………….
………………
} attraper (ExempleException ee) {
/ traiter l'ExampleException
……………….
………………
}
enfin
Cette section optionnelle est exécutée lors de
résiliation de l'un des blocs try ou catch / ci-dessus
Classe : [Link](I.T) SEM - IV Objet : Java de base

………………..
……………….
}

Le bloc finally s'exécutera que l'exception soit levée ou non.

Si une exception est levée, le bloc finally s'exécutera même si aucune instruction catch ne correspond.
the exception. Finally is guaranteed to execute, even if no exceptions are thrown.
Le bloc finally est une position idéale pour fermer les ressources telles que le gestionnaire de fichiers ou un
connexion à la base de données etc.
classe EnfinDémonstration publique {

statique voidprocA() {

essayer{
[Link]("à l'intérieur de procA");
jeter newRuntimeException("démonstration");

}finally{
[Link]("finally de procA");
}
}

//Retourner depuis un bloc try.

static voidprocB(){

essayer{
[Link]("à l'intérieur de procB");
retour;
}
enfin
[Link]("finalement de procB");
}
}

//Exécuter normalement un bloc try.

static void proc C(){}

essayer{
[Link]("à l'intérieur de procC");
}
enfin
[Link]("finalement de procC");
}
}

public static voidmain(String[] args) {

Classe : [Link](I.T) SEM - IV Subject : Core Java

essayer{
procA();
}catch(Exception e){
[Link]("Exception détectée");

procB();
procC();

Écran de sortie :
à l'intérieur de procA
procA est enfin
Exception attrapée
à l'intérieur de procB
procB's enfin
à l'intérieur de procC

Mot-clé Throws :
"throws" est un mot-clé défini dans le langage de programmation Java. Les mots-clés sont essentiellement
mots réservés ayant une signification spécifique pertinente pour un compilateur dans la programmation Java
le mot-clé throw indique ce qui suit :
Le mot-clé throws dans le langage de programmation Java est applicable à une méthode pour indiquer
que la méthode soulève un type particulier d'exception lors de son traitement.
-- Le mot clé throws dans le langage de programmation Java prend des arguments sous forme de liste des
objets de type classe [Link].
-- lorsque nous utilisons le throws avec une méthode, cela s'appelle ducking. La méthode appelant un
Une méthode avec une clause throws doit être encadrée par des blocs try catch.
Exemple d'utilisation du mot-clé throws dans une classe :
importer [Link];
classe publique Class1 {
méthode publique lectureFichier(String fichier)
lance IOException{
<statements>
if (error){
lancer une IOException("erreur
lecture du fichier
}
}
}
Classe : [Link](I.T) SEM - IV Subject : Core Java

classe MyException étend Exception {

public MyException(String msg){
super(msg);
}
}
classe publique Test {

static int divide(int first,int second) throws MyException{

si(seconde==0)
lancer une MyException("ne peut pas être divisé par zéro");
retourner premier/deuxième;
}
public static void main(String[] args) {
essayer {
[Link](diviser(4,0));
}
attraper (MyException exc) {
[Link]();
}
}
}
Class : [Link](I.T) SEM - IV Subject : Core Java

8 - Programmation Orientée Objet

Objets :

L'objet est l'unité de base de la programmation orientée objet.

Les objets sont identifiés par leur nom unique.
Un objet représente une instance particulière d'une classe.
Il peut y avoir plus d'une instance d'un objet. Chaque instance d'un objet peut contenir ses
posséder des données pertinentes.

Un objet est une collection de membres de données et de fonctions membres associées également connues sous le nom de
methods.
Syntaxe :
Nom_Classe Nom_Object;
Object_Nom = new Classe_Nom();
OU
Class_Name Object_Name= new Class_Name();
Exemple :
Supposons que le nom de la classe soit Étudiant alors
Étudiant s = nouveau Étudiant();

Classes :
Les classes sont des types de données sur la base desquels des objets sont créés.
Les objets ayant des propriétés et des méthodes similaires sont regroupés pour former une classe.
Ainsi, une classe représente un ensemble d'objets individuels.
Les caractéristiques d'un objet sont représentées dans une classe comme des Propriétés.
Les actions qui peuvent être effectuées par des objets deviennent des fonctions de la classe et sont
appelés Méthodes.
Par exemple, considérons que nous avons une classe de voitures sous laquelle se trouvent Santro Xing, Alto et Wagan R.
représente des objets individuels. Dans ce contexte, chaqueObjetVoiture aura son propre Modèle, Année de
Fabrication, Couleur, Vitesse Max, Puissance Moteur, etc., qui forment les propriétés de la classe Voiture et
the associated actions i.e., object functions like Start, Move, Stop form the Methods ofCar
Classe.
Class : [Link](I.T) SEM - IV Sujet : Java de base

Aucune mémoire n'est allouée lorsqu'une classe est créée. La mémoire n'est allouée que lorsqu'un objet est
créé, c'est-à-dire lorsqu'une instance d'une classe est créée.

Syntaxe :
Classe Nom_Classe
{

Déclaration de variable de spécificateur d'accès;

Déclaration de fonction de spécificateur d'accès;

Déclaration de variable de spécificateur d'accès ;

Déclaration de fonction de spécificateur d'accès;
};

The keyword‘private’is optional if data or functions are not associated with this keyword then
ils sont supposés être privés par défaut.
Les mots-clés 'private' et 'public' sont appelés 'Spécificateur d'accès'
Les données privées ne peuvent être accessibles que dans la même classe. Les données publiques peuvent être accessibles de l'extérieur.

classe.
Exemple :
classe étudiant
{
int numéros de rouleau;
char name[30];
flottant per;

Exemple :

classe Étudiant
{
public String nom ;
public int rollno ;
public float per ;

vide entrer(Chaîne s, entier r, flottant p)

{
name = s;
rollno = r;
per = p;
}

void afficher()
{
Classe : [Link](I.T) SEM - IV Sujet : Java de base

[Link]("Nom="+nom);
[Link]("Numéro de rouleau="+rollno);
[Link]("Pourcentage="+per);
}

}
classe StudentDemo
{
public static void main(String args[])
{
Étudiant SObj = new Étudiant();

[Link]("Junaid",12,99.77F);

[Link]();

Exemple :
classe Étudiant
{
Classe : [Link](I.T) SEM - IV Subject : Core Java

public String name ;

public int numéroDeRoulette ;
public float per ;

void input(String s, int r, float p)

{
name = s;
rollno = r;
per = p;
}
private void afficher()
{
[Link]("Nom="+name);
[Link]("Numéro de rouleau="+rollno);
[Link]("Percentage="+per);
}

public static void main(String args[])

{
Étudiant sObj = new Étudiant();

[Link]("ABC",2,23.77F)
[Link]();

}
Classe : [Link](I.T) SEM - IV Subject : Core Java

Tableaux d'objets

Tout objet, qu'il soit intégré ou défini par l'utilisateur, peut être stocké dans un tableau.
Lorsque vous déclarez le tableau, vous indiquez au compilateur le type d'objet à stocker et le
nombre d'objets pour lesquels allouer de la place. Le compilateur sait combien de place est
nécessaire pour chaque objet en fonction de la déclaration de classe.
Accéder aux données des membres dans un tableau d'objets est un processus en deux étapes.
Vous identifiez l'élément du tableau en utilisant l'opérateur d'index ([ ]), puis vous ajoutez
l'opérateur de membre (.) pour accéder à un membre variable particulier.

importer [Link].*;
classe Manager
{
int no_of_projects;
Chaîne nom;

void getData(int no, String n)

{
no_of_projects = no;
name = n;
}

void mettreDonnées()
{
[Link]("No_Of_Projects="+no_of_projects);
[Link]("Manager Name="+name);
}
}
classe ManagerDemo
{
public static void main(String args[])
{
Manager[] mObj = new Manager[3];

mObj[0] = new Gestionnaire();

mObj[1] = new Manager();
mObj[2] = nouveau Manager();

Scanner sc = new Scanner([Link]);

pour(int i=0;i<3;i++)
Classe : [Link](I.T) SEM - IV Sujet : Java de base

[Link]("Entrez le nom du responsable=");

String strName = [Link]();
[Link]("Entrez le nombre de projets=");
int nombre = [Link]();
mObj[i].getData(number,strName);

pour(int j=0;j<3;j++)
{
mObj[1].putData();
}

}
}

Membres de données statiques :

Les classes peuvent contenir des données membres statiques et des fonctions membres.
Lorsqu'un membre de données est déclaré comme statique, une seule copie des données est conservée pour tous
objets de la classe.
Classe : [Link](I.T) SEM - IV Sujet : Java de base

Les membres de données statiques ne font pas partie des objets d'un type de classe donné ; ils sont séparés.
objets.
En conséquence, la déclaration d'un membre de données statiques n'est pas considérée comme une définition.
Le membre de données est déclaré dans le scope de la classe, mais la définition est effectuée au scope du fichier.
Ces membres statiques ont une liaison externe. L'exemple suivant l'illustre :

Caractéristiques des membres de données statiques :

Il est initialisé à zéro lorsque le premier objet de la classe est créé. Lors d'autres initialisations
est permis.
Une seule copie de ce membre est créée pour toute la classe et les autres objets partagent cela.
copie.
Il est visible uniquement au sein de la classe, mais sa durée de vie s'étend sur l'ensemble du programme.

Exemple :
/*
Membres de données statiques et fonctions membres
*/

classe StaticDemo
{
static int count;
int code=7;

void afficherCompte()
{

[Link]("Compteur="+compteur);
[Link]("Code="+code);
}
public static void main(String args[])
{
StaticDemo sd = new StaticDemo();
[Link]();
//[Link]("Code="+code);
[Link]("Count="+count);
Classe : [Link](I.T) SEM - IV Sujet : Java de base

Fonction membre statique :

La fonction statique est définie en utilisant le mot-clé statique avant la fonction membre qui doit être
déclaré comme fonction statique.

Syntaxe générale :

type_de_retour_statique fonction_nom() {//corps}

Caractéristiques de la fonction membre statique :

Une fonction statique ne peut accéder qu'aux autres données ou membres statiques déclarés dans le
classe.
Une fonction statique peut être appelée en utilisant le nom de la classe au lieu des objets.

Accéder à une fonction statique :

Une fonction membre normale est accédée en utilisant l'objet et un opérateur appelé le point membre.
opérateur d'accès. Les fonctions déclarées statiques ou les fonctions statiques sont accessibles uniquement par la classe
le nom et l'opérateur de résolution de portée, contrairement aux fonctions membres normales où ceux-ci ne sont pas
utilisé.

Exemple :
classe MembreStatique
Classe : [Link](I.T) SEM - IV Sujet : Java de base

{
static int code;
int count = 2;
static void afficher()
{
[Link]("Code="+code);
}

void montrer()
{
[Link]("Compte="+count);
[Link]("Code="+code);
}
}

classe StaticMemberTest
{
public static void main(String args[])
{
StaticMember sm = new StaticMember();

[Link]();

[Link]();
}
}

Constructeurs :

Les constructeurs sont utilisés pour initialiser les objets.

Un constructeur est une sorte spéciale de fonction qui est membre de la classe.
Le nom du constructeur est le même que le nom de la classe.
Un constructeur est appelé automatiquement lorsque l'objet est créé.
Un constructeur n'a pas de type de retour.
Classe : [Link](I.T) SEM - IV Sujet : Java de base

Exemple:
classe ConsDemo
{

int a,b;
public ConsDemo()
{
a = 0;
b = 1;
}

void montrer()
{
[Link]("a="+a);
[Link]("b="+b);
}

}
classe ConsDemoTest
{

public static void main(String args[])

{

ConsDemo cd = new ConsDemo();

[Link]();
}

}
Classe : [Link](I.T) SEM - IV Sujet : Java de base

Types de constructeurs :

Constructeurs par défaut

Dans l'ordinateurlangages de programmation tLe terme « constructeur par défaut » fait référence à

unconstructeur tqui est généré automatiquement en l'absence de constructeurs explicites

Un constructeur par défaut est un constructeur sans paramètres.
Si aucun constructeur n'est défini par l'utilisateur, le compilateur fournit le constructeur par défaut.
Une fois que le constructeur est défini par l'utilisateur, le compilateur ne fournit pas de défaut.
Le constructeur et ensuite l'utilisateur est responsable de définir le constructeur par défaut.

Constructeur paramétré :
JAVA permet d'atteindre cela en passant des arguments à la fonction constructeur quand le
des objets sont créés.
Le constructeur qui peut prendre des arguments est appelé constructeur paramétré.

Syntaxe :
classe <cname>
{
//data
public : cname(arguments);
.........
.........
};
Exemples :
classe étudiant
{
char name[20];
int rno;
public: étudiant(char,int);

};
student :: student(char n,int r)
{
name=n;
rno=r;
}

Exemple :
importer [Link].*;
classe ParaDemo
{
int a,b;

public ParaDemo(int a,int b)

Classe : [Link](I.T) SEM - IV Subject : Core Java

{
this.a = a;
this.b = b;
}
void afficher()
{
[Link]("a="+a);
[Link]("b="+b);
}
}
classe ParaDemoTest
{
public static void main(String args[])
{

Scanner sc = new Scanner([Link]);

[Link]("Entrez les nombres=");
int num1 = [Link]();
int num2 = [Link]();

ParaDemo pd = new ParaDemo(num1,num2);

[Link]();
}
}

ce mot-clé :
Le mot-clé 'this' est utile lorsque vous devez faire référence à une instance de la classe à partir de celle-ci.

méthode.
Le mot-clé nous aide à éviter les conflits de noms.
Comme nous pouvons le voir dans le programme, nous avons déclaré le nom de la variable d'instance et
variables locales identiques.

Now to avoid the confliction between them we usethiskeyword.

Classe : [Link](I.T) SEM - IV Subject : Core Java

Here, this section provides you an example with the complete code of the program for the
illustration de ce qu'est ce mot clé et comment l'utiliser.
Dans l'exemple, [Link] et [Link] se réfèrent aux variables d'instance length et breadth.
tandis que la longueur et la largeur font référence aux arguments passés dans la méthode. Nous avons créé un programme
à travers cela. Après l'avoir parcouru, vous pouvez mieux comprendre.
Voici le code du programme :
classeRectangle{
intlength,breadth;
void afficher(int longueur, int largeur) {
[Link]=longueur;
[Link]=largeur;
}
intcalculer(){
retourner(longueur*largeur);
}
}
public classUseOfThisOperator{
public static void main(String[] args) {
Rectangle rectangle=newRectangle();
[Link](5,6);
intarea = [Link]();
[Link]("L'aire d'un rectangle est : " + area);
}
}

La sortie du programme est donnée ci-dessous :

C:\java>java
UtilisationDeCetOpérateur
L'aire d'un rectangle est : 30

Mot-clé final en Java

Une variable java peut être déclarée en utilisant le mot-clé final. Ensuite, la variable finale peut être
assigné une seule fois.
Une variable qui est déclarée comme finale et non initialisée est appelée une variable finale vierge.
Une variable finale vide oblige les constructeurs à l'initialiser.
Les classes Java déclarées comme final ne peuvent pas être étendues. Limitation de l'héritage !
Les méthodes déclarées comme finales ne peuvent pas être substituées. Dans les méthodes, privé est égal à final, mais
dans les variables, ce n'est pas le cas.
paramètres finaux – les valeurs des paramètres ne peuvent pas être modifiées après l'initialisation. Faire un
petit exercice Java pour découvrir les implications des paramètres finals dans la redéfinition de méthodes.
Les classes locales Java ne peuvent référencer que des variables locales et des paramètres qui sont déclarés comme
final
Classe : [Link](I.T) SEM - IV Subject : Core Java

Un avantage visible de déclarer une variable java comme static final est que la classe java compilée
résultats en une performance plus rapide.

Écriture d'une méthode finalize()

Avant qu'un objet ne soit collecté comme inutile, le système d'exécution appelle sa méthode finalize(). L'intention est
pour finalize() afin de libérer les ressources système telles que les fichiers ouverts ou les sockets ouverts avant d'obtenir
collecté.

Java utilise la méthode finalize() pour la collecte des ordures.

Votre classe peut assurer sa finalisation simplement en définissant et en implémentant une méthode dans votre
classe nommée finalize(). Votre méthode finalize() doit être déclarée comme suit :
protected void finalize () throws throwable

Surcharge de fonction :-

• Java vous permet de créer plusieurs fonctions avec le même nom.

• Ceci s'appelle la surcharge de fonction.
• Les fonctions doivent différer par leur liste de paramètres, avec un type de paramètre différent, un
nombre différent de paramètres, ou les deux. Voici un exemple :

int maFonction (int, int);

int maFonction (long, long);
int maFonction (long);
maFonction()

est surchargé avec trois listes de paramètres différentes. Les première et deuxième versions diffèrent par les types
des paramètres, et le troisième diffère par le nombre de paramètres.
• Les types de retour peuvent être les mêmes ou différents sur les fonctions surchargées.
• Vous devriez noter que deux fonctions avec le même nom et la même liste de paramètres, mais différentes
Les types de retour génèrent une erreur de compilation.

• La surcharge de fonction est également appelée polymorphisme de fonction. Poly signifie plusieurs, et
morph signifie forme : une fonction polymorphe est multi-forme.

Exemple :
classe OverloadingDemo
{
void ajouter(int num1, int num2)
{
int somme = num1 + num2;
[Link]("Somme des variables entières=" + somme);
}
Classe : [Link](I.T) SEM - IV Objet : Java de base

void ajouter(double num1, double num2)

{
double somme = num1 + num2;

[Link]("Somme des variables doubles=" + sumd);

}
}

classe TestLoading
{
public static void main(String args[])
{

OverloaingDemo od = new OverloaingDemo();

[Link](5,6);
[Link](5.5,6.6);
}
}

Surcharge de constructeur
Si vous avez un constructeur avec le même nom et des arguments différents, alors c'est
appelé surchage de constructeur.
classe Chambre
{
double longueur, largeur, hauteur;

Chambre(double l,double b,double h)

{
length=l;
breadth=b;
height=h;
}
Classe : [Link](I.T) SEM - IV Objet : Core Java

Chambre()
{
length=-1;
breadth=-1;
height=-1;
}

Chambre(double len)
{
longueur=largeur=hauteur=len;
}

double volume()
{
return longueur * largeur * hauteur;
}

Classes imbriquées / Classes internes :

Le langage de programmation Java vous permet de définir une classe à l'intérieur d'une autre classe. Une telle classe est
appelée une classe imbriquée et est illustrée ici :
classe OuterClass {
...
class NestedClass {
...
}
}

Les classes imbriquées sont divisées en deux catégories : statiques et non statiques. Les classes imbriquées qui sont
déclaréstatiquesont simplement appelées classes imbriquées statiques. Les classes imbriquées non statiques sont appelées classes internes
classes.

classe OuterClass {
...
classe statique ClasseImbriquéeStatique {
...
}
classe InnerClass {
...
}
}
Une classe imbriquée est un membre de sa classe englobante.
Les classes imbriquées non statiques (classes internes) ont accès aux autres membres de la classe englobante.
même s'ils sont déclarés privés.
Classe : [Link](I.T) SEM - IV Subject : Core Java

Les classes imbriquées statiques n'ont pas accès aux autres membres de la classe englobante. En tant que membre de
leClasseExterne, une classe imbriquée peut être déclaréeprivé, public,protégé,
Pourquoi utiliser des classes imbriquées ?
Il existe plusieurs raisons d'utiliser des classes imbriquées, parmi lesquelles :
C'est une manière de regrouper logiquement des classes qui ne sont utilisées qu'à un seul endroit.
Cela augmente l'encapsulation.
Les classes imbriquées peuvent conduire à un code plus lisible et plus maintenable.

classe publiqueClasseExterieure
{
privéChaînevarInstanceExtérieure;

classe publiqueClasseInterne
{
public void printVars()
{
[Link]( "Imprimer la variable d'instance de la classe externe:" +

outerInstanceVar);
}
}
}

La classe interne a accès aux variables et méthodes de l'instance de la classe englobante, même privées,
comme indiqué ci-dessus. Cela le rend très différent de la classe imbriquée en C++, qui est équivalente à la
"static" classes internes, voir ci-dessous.
Un objet intérieur a une référence à l'objet extérieur. L'objet imbriqué ne peut être créé qu'avec un
référence à l'objet 'extérieur'. Voir ci-dessous.

public voidtestInner()
{
...
OuterClass extérieur =nouveauOuterClass();
[Link] intérieur = [Link]();
...
}

Exemple :
classe Extérieur
{
int a=1;

classe Intérieure
{
Classe : [Link](I.T) SEM - IV Sujet : Java de base

void showb()
{
[Link]("a="+a);
}
}
}
classe NestedDemo
{
public static void main(String args[])
{
Outer out1 = new Outer();
[Link] in1 = [Link] Inner();

[Link]();
}

Visibility control:

Membres publics :
Les membres publics peuvent être accessibles par n'importe quel objet de la classe.
Lorsqu'il précède une liste de membres de classe, le mot-clé public spécifie que ces membres sont
accessible depuis n'importe quelle fonction. Cela s'applique à tous les membres déclarés jusqu'au prochain spécificateur d'accès
ou la fin du cours.

classe A
{

int pubFunc()
{
retourner 0;
}
};

Membres privés :
Tous les membres d'une classe - données et méthodes - sont privés par défaut. Les membres privés peuvent être accédés
ne peut être utilisé que dans les méthodes de la classe elle-même.
Classe : [Link](I.T) SEM - IV Sujet : Java de base

classe A
{
int pubFunc() privé
{
retourner 0;
}
};

Protected Members:
Le mot-clé protégé spécifie l'accès aux membres de la classe dans la liste-des-membres jusqu'au suivant.
spécificateur d'accès (public ou privé) ou à la fin de la définition de la classe. Membres de la classe déclarés
comme protégé ne peut être utilisé que par les suivants :
Fonctions membres de la classe qui a initialement déclaré ces membres.
Amis de la classe qui a initialement déclaré ces membres.
Les classes dérivées avec un accès public ou protégé de la classe qui a été déclarée à l'origine
ces membres.
Classes dérivées directement privées qui ont également un accès privé aux membres protégés.

classe A
{
int pubFunc() protégé
{
retourner 0;
}
};

/*
Programme pour déclarer une classe Livre avec les membres de données suivants
1)name
enchère
3)auth_name
4)price

Acceptez ces informations pour trois livres ?

*/

import [Link].*;
classe Livre
{
Chaîne nom;
int enchère;
String Auth_name;
Classe : [Link](I.T) SEM - IV Sujet : Java de base

int prix;

void bookInput()
{

essayer
{
BufferedReader br = new BufferedReader(new
InputStreamReader([Link]));
[Link]("Entrez le nom du livre=");
nom = [Link]();
[Link]("Entrez l'ID du livre=");
offre = [Link]([Link]());
[Link]("Entrez le nom de l'auteur=");
Auth_name = [Link]();
[Link]("Enter The Price=");
prix = [Link]([Link]());

}
attraper(IOException e)
{
[Link](e);
}
}

void afficher()
{
[Link]("Nom du livre="+name);
[Link]("Identifiant du livre="+bid);
[Link]("Nom de l'auteur="+Auth_name);
[Link]("Prix="+prix);
}

classe BookDemo
{
public static void main(String args[])
{
Livre[] b = nouveau Livre[3];

b[0] = nouveau Livre();

b[1] = new Livre();
b[2] = new Livre();

pour(int i=0;i<3;i++)
Classe : [Link](I.T) SEM - IV Objet : Java de base

{
b[i].livreEntree();
}

pour(int i=0;i<3;i++)
{
b[i].afficher();
}
}
}

Exemple de Responsable :
importer [Link].*;
classe Responsable
{
int nombre_de_projets;
Chaîne nom;

void getData(int no, String n)

{
no_of_projects = no;
name = n;
}

void mettreDesDonnées()

{
[Link]("Nombre_De_Projets="+no_of_projects);
[Link]("Nom du manager="+name);
}
}
classe ManagerDemo
{
public static void main(String args[])
{
Manager[] mObj = new Manager[3];

mObj[0] = nouveau Manager();

mObj[1] = new Gestionnaire();
mObj[2] = new Manager();

Scanner sc = new Scanner([Link]);

pour(int i=0;i<3;i++)
Classe : [Link](I.T) SEM - IV Sujet : Java de base

[Link]("Entrez le nom du responsable=");

Chaîne strName = [Link]();
[Link]("Entrez le nombre de projets=");
int nombre = [Link]();
mObj[i].getData(number,strName);

pour(int j=0;j<3;j++)
{
mObj[1].putData();
}

}
}
Classe : [Link](I.T) SEM - IV Objet : Java de base

9 - Héritage

{"Definitions":"Définitions"}
L'idée d'héritage est simple mais puissante : lorsque vous souhaitez créer une nouvelle classe
et il existe déjà une classe qui inclut une partie du code que vous souhaitez, vous pouvez dériver
votre nouvelle classe de la classe existante.
Une classe qui est dérivée d'une autre classe est appelée une sous-classe (également une classe dérivée,
classe étendue, ou classe enfant.
La classe dont la sous-classe est dérivée est appelée superclasse (également classe de base ou une
classe parente).
Une sous-classe hérite de tous les membres (champs, méthodes et classes imbriquées) de sa
superclasse. Les constructeurs ne sont pas des membres, donc ils ne sont pas hérités par les sous-classes, mais le
Le constructeur de la superclasse peut être invoqué depuis la sous-classe.
est implicitement une sous-classe deObjet.
Les classes peuvent être dérivées de classes qui sont dérivées de classes qui sont dérivées de
classes, et ainsi de suite, et finalement dérivées de la classe la plus haute,Objet. Une telle classe est
a dit d'être descendu de toutes les classes de la chaîne d'héritage remontant à
Objet.

Toutes les classes de la plateforme Java sont des descendants de l'objet

At the top of the hierarchy,Objectis the most general of all classes. Classes near the
le bas de la hiérarchie fournit un comportement plus spécialisé.
Classe : [Link](I.T) SEM - IV Subject : Core Java

Un exemple d'héritage

Voici le code d'exemple pour une possible implémentation d'une classeBicycle qui a été présentée
dans la leçon Classes et Objets :
classe publique Bicycle {

//La classe Bicycle a trois champs

public int cadence;
public int vitesse;
public int vitesse;

La classe Bicycle a un constructeur.

public Bicycle(int startCadence, int startSpeed, int
startGear) {
gear = startGear;
cadence = startCadence;
vitesse = vitesseInitiale;
}

//la classe Bicycle a quatre méthodes

public void setCadence(int nouvelleValeur) {
cadence = newValue;
}

public void setGear(int newValue) {

gear = newValue;
}

public void appliquerFrein(int diminution) {

vitesse -= décrément;
}

public void accelerer(int increment) {

vitesse += incrément;
}

}
Classe : [Link](I.T) SEM - IV Subject : Core Java

Types d'héritage :

Simple / Unique
Multiniveau

Héritage simple
One Super Class and one base class .
Dans "l'héritage simple", une forme courante d'héritage, les classes n'ont qu'une seule classe de base.

Syntaxe :
Classe Class_Name
{
Access Specifier:
Déclaration des membres de données;
Déclaration de fonction membre;
}
Classe Class_Name1 : SpécificateurDAccès Class_Name
{
Access Specifier:
Déclaration des Données_Membres;
Déclaration de Fonction_Membre;

Example:
classe Parent
{
public :
flotte hauteur;
char couleur_de_cheveux[30] ;
char couleur_des_yeux[30];
}
classe enfant : publique Parent
{
// Détails de l'enfant ;
}
Classe : [Link](I.T) SEM - IV Sujet : Java de base

classe publique A
{
}
public class B étend A
{
}
Multilevel Inheritance
L'héritage multi-niveaux est le processus de création d'une nouvelle classe à partir d'une classe déjà dérivée. Ici
La classe dérivée existante est une classe de base intermédiaire. La nouvelle classe créée est une classe dérivée.
Représentation diagrammatique :

classe publique A
{
}
public class B étend A
{
}
classe publique C étend B
{
}

par exemple
classeA {
Classe : [Link](I.T) SEM - IV Subject : Core Java

intx;
inty;
intget(intp,intq){
x=p; y=q;return(0);
}
voidMontrer(){
[Link](x);
}
}
classeBétendA{
voidShowb(){
[Link]("B");
}
}

classeCétendB{
voiddisplay() {
[Link]("C");
}
public static voidmain(String args[]){
A a =newA();
[Link](5,6);
[Link]();
}
}

Mot-clé final Java

Une variable Java peut être déclarée en utilisant le mot-clé final. Ensuite, la variable finale peut être
attribué seulement une fois.
Une variable qui est déclarée comme finale et non initialisée est appelée une variable finale vierge.
Une variable finale vide oblige les constructeurs à l'initialiser.
Les classes Java déclarées comme finales ne peuvent pas être étendues. Limitation de l'héritage !
Les méthodes déclarées comme finales ne peuvent pas être remplacées. Dans les méthodes, privé est équivalent à final, mais
dans les variables ce n'est pas.
les paramètres finaux - les valeurs des paramètres ne peuvent pas être modifiées après l'initialisation. Faites un
petit exercice java pour découvrir les implications des paramètres final dans la redéfinition de méthode.
Les classes locales Java ne peuvent référencer que les variables locales et les paramètres qui sont déclarés comme
final
Un avantage visible de déclarer une variable Java comme static final est que la classe Java compilée
résultats en une performance plus rapide.
Classe : [Link](I.T) SEM - IV Sujet : Java de base

Méthodes et classes abstraites

Une classe abstraite est une classe qui est déclarée abstraite - elle peut inclure ou non
abstract methods. Abstract classes cannot be instantiated, but they can be subclassed.
Une méthode abstraite est une méthode qui est déclarée sans implémentation.
des accolades, suivies d'un point-virgule), comme ceci :
abstrait void moveTo(double deltaX, double deltaY);
Si une classe inclut des méthodes abstraites, la classe elle-même doit être déclarée abstraite, comme ceci :
classe abstraite publique GraphicObject {
// declare fields
// déclarer des méthodes non abstraites
abstract void dessiner();
Lorsqu'une classe abstraite est sous-classée, la sous-classe fournit généralement des implémentations pour
toutes les méthodes abstraites de sa classe parente. Cependant, si ce n'est pas le cas, la sous-classe doit
peut également être déclaré abstrait.

Un Exemple de Classe Abstraite

Dans une application de dessin orientée objet, vous pouvez dessiner des cercles, des rectangles, des lignes, des courbes de Bezier.
courbes, et de nombreux autres objets graphiques. Ces objets ont tous certains états (pour
exemple : position, orientation, couleur de ligne, couleur de remplissage) et comportements (par exemple : se déplacer vers
faire pivoter, redimensionner, dessiner) en commun. Certains de ces états et comportements sont les mêmes pour
tous les objets graphiques - par exemple : position, couleur de remplissage et moveTo. D'autres nécessitent

différentes implémentations—par exemple, redimensionner ou dessiner.

Tous les objets graphiques doivent savoir comment se dessiner ou se redimensionner ; ils diffèrent simplement par
comment ils le font. C'est une situation parfaite pour une superclasse abstraite. Vous pouvez prendre
avantage des similitudes et déclarer tous les objets graphiques pour hériter du même
objet parent abstrait - par exemple, GraphicObject, comme montré dans ce qui suit
figure.

Les classes Rectangle, Ligne, Bézier et Cercle héritent de GraphicObject

Tout d'abord, vous déclarez une classe abstraite,GraphicObject, pour fournir des variables et des méthodes de membre
qui sont entièrement partagés par toutes les sous-classes, comme la position actuelle et ledéplacerVersméthode.
ObjetGraphiquedéclare également des méthodes abstraites pour des méthodes, telles quedessinerouredimensionner, qui a besoin
à mettre en œuvre par toutes les sous-classes mais devant être implémenté de différentes manières. Le
ObjetGraphiquela classe peut ressembler à quelque chose comme ceci :
classe abstraite ObjetGraphique {
int x, y;
...
Classe : [Link](I.T) SEM - IV Sujet : Java de base

void moveTo(int newX, int newY) {

...
}

méthode abstraite vide dessiner();

méthode abstraite void redimensionner();

}
Chaque sous-classe non abstraite de GraphicObject, comme Circle et Rectangle, doit
fournir des implémentations pour les méthodes de dessin et de redimensionnement :

classe Cercle étend ObjetGraphique {

void dessiner() {
...
}
void redimensionner() {
...
}
}
classe Rectangle étend GraphicObject {
void dessiner() {
...
}
void redimensionner() {
...
}
}

Interfaces
Une interface dans lelangage de programmation Javas entype abstrait tqui est utilisé pour spécifier
uninterfacedans le sens générique du terme) queclasses mjuste mettre en œuvre.
Les interfaces sont déclarées en utilisant leinterfacekeyword, et ne peut contenir queméthode
signatures aet les déclarations de constantes (déclarations de variables qui sont déclarées comme étant à la fois
statiqueetfinal).
Une interface ne peut jamais contenir de définitions de méthodes.
Les interfaces ne peuvent pas être instanciées. Une classe qui implémente une interface doit implémenter tout
des méthodes décrites dans l'interface, ou être unclasse abstraite.
Un avantage de l'utilisation des interfaces est qu'elles simulenthéritage multiple.
Toutes les classes en Java (autres [Link], leclasse racine ole Javatype
système)doit avoir exactement unclasse de base;héritage multiple deles classes ne sont pas autorisées.
De plus, une classe Java peut implémenter, et une interface peut étendre, n'importe quel nombre de
interfaces ; cependant, une interface ne peut pas implémenter une interface.

[visibilité] interfaceNomDeLInterface[étendautre
interfaces] {
déclarations de constantes
déclarations de méthode abstraite
Classe : [Link](I.T) SEM - IV Sujet : Java de base

interface Rebondissable
{
void setBounce(); // Notez le point-virgule :
// Interface methods are public
et abstrait.
Considérez-les comme des prototypes
uniquement; aucune mise en œuvre n'est autorisée.
}
La syntaxe pour implémenter une interface utilise cette formule :
... implementsInterfaceName[,another interface,another,
...] ...
Classes mpar exemple, implémentez une interface.
public class Lion implements Predator {

public boolean chasserProie(Prey p) {

// programmation pour chasser la proie p (spécifiquement
pour un lion)
}

public void mangerProie (Proie p) {

// programmation pour manger la proie p (spécifiquement
pour un lion)
}
}
Si une classe implémente une interface et n'implémente pas toutes ses méthodes, elle doit être
marqué commeabstraitSi une classe est abstraite, l'un de sessous-classes iest censé mettre en œuvre
ses méthodes non implémentées.
Les classes peuvent implémenter plusieurs interfaces
public class Frog implements Predator, Prey { ... }
Les interfaces sont couramment utilisées dans le langage Java pourrappels.
Java ne permet pas de passer des méthodes (procédures) en tant qu'arguments.

mot-clé super
Le super est un mot-clé java. Comme son nom l'indique, super est utilisé pour accéder aux membres de
la super classe. Elle est utilisée à deux fins en java.
La première utilisation du mot-clé super est d'accéder aux variables de données cachées de la super classe.
caché par la sous-classe.
Par exemple, supposons que la classe A est la superclasse qui a deux variables d'instance, à savoir un int a et un float b.
La classe B est la sous-classe qui contient également ses propres membres de données appelés a et b. Ensuite, nous
peut accéder aux variables a et b de la super classe (classe A) à l'intérieur de la sous-classe classe B simplement en
appelant la commande suivante.
[Link];
Classe : [Link](I.T) SEM - IV Sujet : Java de base

Ici, un membre peut soit être une variable d'instance, soit une méthode. Cette forme de super est la plus élevée.
utile pour gérer des situations où les membres locaux d'une sous-classe masquent les membres d'un
super classe ayant le même nom. L'exemple suivant clarifie toutes les confusions.
classeA{
inta;
flottantb;
voidAfficher(){}
[Link]("b dans la super classe : " + b);
}

classeBétendA{
inta
flottantb
B(intp,floatq){
a = p;
super.b = q;
}
voidShow() {
[Link]();
[Link]("b dans la super classe : " + super.b);
[Link]("a dans la sous-classe :" + a);
}

public static void main(String[] args) {

B subobj = newB(1, 5);
[Link]();
}
}

Output:
C:\>java B
b dans la super classe : 5.0
b dans la super classe : 5.0
a dans la sous-classe : 1

super(param-list);
Classe : [Link](I.T) SEM - IV Sujet : Java de base

Ici, la liste des paramètres est la liste des paramètres requis par le constructeur dans le super
classe.
super doit être la première instruction exécutée à l'intérieur d'un constructeur de super classe.
Si nous voulons appeler le constructeur par défaut, nous passons la liste de paramètres vide.
le programme suivant illustre l'utilisation du mot clé super pour appeler une super classe
constructeur.
classeA{
inta;
intb;
intc;
A(intp,intq,intr){
a=p;
b=q;
c=r;
}
}

classeBétendA{
intd;
B(intl,intm,intn,into){
super(l,m,n);
d=o;
}
voidShow(){}
[Link]("a = " + a);
[Link]("b = " + b);
[Link]("c = " + c);
[Link]("d = " + d);
}

public static voidmain(String args[]){

B b =newB(4,3,8,7);
[Link]();
}
}
Output:
C:\>java B
a=4
b=3
c=8
d=7
Classe : [Link](I.T) SEM - IV Subject : Core Java

Surcharge de méthode :-
Dans une hiérarchie de classes, lorsqu'une méthode dans une sous-classe a le même nom et la même signature de type
comme une méthode dans sa superclasse, alors la méthode dans la sous-classe est dite écraser la
méthode dans la super classe.
Lorsqu'une méthode redéfinie est appelée depuis une sous-classe, elle fera toujours référence à la
version de cette méthode définie par la sous-classe.
La version de la méthode définie par la superclasse sera masquée.
Considérez ce qui suit :
// Surcharge de méthode.
classe A {
int i, j;
A(int a, int b) {
i = a;
j = b;
}
// afficher i et j
void montrer() {
[Link]("i et j : " + i + " " + j);
}
}
classe B étend A {
int k;
B(int a, int b, int c) {
super(a, b);
k = c;
}
// afficher k–cela remplace show() dans A
vide montrer() {
[Link]("k : " + k);
}
}
classe Surtaxe {
public static void main(String args[]) {
B subOb = new B(1, 2, 3);
[Link](); // cela appelle show() dans B
}
}

La sortie produite par ce programme est montrée ici :

k:3
Classe : [Link](I.T) SEM - IV Sujet : Java de base

Lorsque show( ) est appelé sur un objet de type B, la version de show( ) définie dans B
est utilisé. C'est-à-dire que la version de show() à l'intérieur de B remplace la version déclarée dans A. Si
si vous souhaitez accéder à la version de la superclasse d'une fonction surchargée, vous pouvez le faire en
utiliser super. Par exemple, dans cette version de B, la version de la superclasse de show( ) est
invoqué dans la version de la sous-classe. Cela permet à toutes les variables d'instance d'être affichées.
Dispatch dynamique de méthode :

Le dispatch dynamique de méthodes (également connu sous le nom de liaison dynamique) est le processus de mappage

unmessage tune séquence spécifique de code(méthode)àtemps d'exécution.

Cela est fait pour soutenir les cas où la méthode appropriée ne peut pas être déterminé[Link]
tempsc'est-à-dire de manière statique).
Le dispatch dynamique est seulement utilisé pour l'invocation de code et non pour d'[Link] PRocesses

classe A {
void callme() {
[Link]("À l'intérieur de la méthode callme d'A");

}
}
classe B étend A {
void appeler() {
[Link]("À l'intérieur de la méthode callme de B");

}
}
classe C étend A {
void callme() {
[Link]("À l'intérieur de la méthode callme de C");

}
}

classe Répartition {
public static void main(String args[]) {
A a = new A(); // objet de type A
B b = new B(); // objet de type B
C c = new C(); // objet de type C
A r; // obtenir une référence de type A

r = a; // r fait référence à un objet A

Classe : [Link](I.T) SEM - IV Subject : Core Java

[Link](); // appelle la version d'A de appelleMoi

r = b; // r fait référence à un objet B

[Link](); // appelle la version de B de appelleMoi

r = c; // r se réfère à un objet C
[Link](); // appelle la version de callme de C

}
}

10 - Multithreading :

Multitasking:-

Le multitâche permet d'exécuter plus d'une tâche en même temps, une tâche étant un
programme.
Dans le multitâche, seul un CPU est impliqué mais il peut passer d'un programme à l'autre.
un autre programme si rapidement c'est pourquoi cela donne l'impression d'exécuter tout le
programmes en même temps.F
Le multitâche permet aux processus (c'est-à-dire aux programmes) de s'exécuter simultanément sur le programme.
Exemple d'exécution du programme tableur et vous travaillez avec un traitement de texte
aussi.
Le multitâche consiste à exécuter des processus lourds par un seul système d'exploitation.

Multithreading :
Le multithreading est une technique qui permet à un programme ou à un processus d'exécuter de nombreuses tâches.
concurrentiellement (en même temps et en parallèle). Cela permet à un processus d'exécuter ses tâches dans
mode parallèle sur un système à processeur unique
Dans le concept de multithreading, plusieurs processus légers multiples sont exécutés dans un seul
processus/tâche ou programme par un seul processeur.
Par exemple, lorsque vous utilisez un traitement de texte, vous effectuez de nombreuses tâches différentes telles que
comme l'impression, la vérification orthographique, etc. Les logiciels multithread traitent chaque processus comme un

programme séparé.
En Java, la Machine Virtuelle Java (JVM) permet à une application d'avoir plusieurs fils d'exécution.
exécution en cours simultanément.
Classe : [Link](I.T) SEM - IV Sujet : Java de base

Cela permet à un programme d'être plus réactif envers l'utilisateur. Lorsqu'un programme contient
plusieurs fils alors le CPU peut passer d'un fil à l'autre pour les exécuter à
le même temps.
Le multithreading est important pour Java pour deux raisons principales. Tout d'abord, le multithreading permet
vous à écrire des programmes très efficaces car cela vous permet d'utiliser le temps d'inactivité qui est
présent dans la plupart des programmes.

La plupart des périphériques d'entrée/sortie, qu'il s'agisse de ports réseau, de disques durs ou du clavier, sont
beaucoup plus lent que le CPU.
Ainsi, un programme passera souvent une grande partie de son temps d'exécution à attendre d'envoyer ou
recevoir des informations à partir d'un appareil ou vers un appareil. En utilisant le multithreading, votre programme peut

exécutez une autre tâche pendant ce temps d'inactivité.

Par exemple, tandis qu'une partie de votre programme est en train d'envoyer un fichier sur Internet, une autre
partie peut être

gérer l'interaction utilisateur (comme les clics de souris ou les appuis sur des boutons), et encore un autre peut
être en train de mettre en mémoire le prochain bloc de données à envoyer.

La deuxième raison pour laquelle le multithreading est important pour Java concerne le Java’s
modèle de gestion d'événements. Un programme (comme un applet) doit réagir rapidement à un événement
et ensuite revenir. Un gestionnaire d'événements ne doit pas conserver le contrôle du CPU pendant une période prolongée.

période de temps.
Deux threads ou plus peuvent communiquer entre eux par des méthodes qui sont
défini par Object. Ces méthodes sont wait( ), notify( ), et notifyAll( ). Elles permettent à un
fil pour attendre un autre. Par exemple, si un fil utilise une ressource partagée, alors
un autre fil doit attendre jusqu'à ce que le premier fil soit terminé. Le fil d'attente peut
reprendre l'exécution lorsque le premier thread l'informe que la ressource est maintenant disponible.

Les fils peuvent faire partie d'un groupe. Un groupe de fils vous permet de gérer des fils liés.
collectivement. Par exemple, vous pouvez obtenir un tableau des fils dans le groupe.

Le système de multithreading de Java est basé sur la classe Thread et son interface compagnon.
Runnable. Un thread encapsule un fil d'exécution. Pour créer un nouveau thread, votre
le programme mettra soit en œuvre l'interface Runnable soit étendra Thread. Les deux Runnable
et Thread sont regroupés dans [Link]. Ainsi, ils sont automatiquement disponibles pour tous.
programmes.
Classe : [Link](I.T) SEM - IV Sujet : Java de base

L'interface Runnable
L'interface [Link] abstrait une unité de code exécutable. Vous pouvez construire un
fil sur tout objet qui implémente l'interface Runnable. Par conséquent, toute classe que vous
l'intention de s'exécuter dans un fil séparé doit implémenter Runnable. Runnable ne définit qu'un seul
méthode appelée run( ), qui est déclarée comme ceci :
void run()

À l'intérieur de run( ), vous définirez le code qui constitue le nouveau thread. Il est important de
comprenez que run( ) peut appeler d'autres méthodes, utiliser d'autres classes et déclarer des variables tout comme
le fil principal. La seule différence est que run( ) établit le point d'entrée pour un autre,
fil d'exécution concurrent dans votre programme. Ce fil se terminera lorsque run( ) renverra.

Une fois que vous avez créé une instance d'une classe qui implémente Runnable, vous créez un thread en
construire un objet de type Thread, en passant l'instance Runnable. Pour démarrer le thread
Pour démarrer, vous appelerez start() sur l'objet Thread, comme décrit dans la section suivante.

La Classe Thread

La classe Thread encapsule un fil. Elle est emballée dans [Link] et implémente le
Interface Runnable. Par conséquent, une deuxième façon de créer un thread est d'étendre Thread et
remplacer la méthode run( ). Le thread définit également plusieurs méthodes qui aident à gérer les threads.
Voici ceux utilisés dans ce chapitre :
Les méthodes définies par InputStream
Créer un fil
Lorsqu'un thread est créé, il doit être lié de manière permanente à un objet avec une méthode run().
Lorsque le thread est lancé, il invoquera la méthode run() de l'objet. Plus spécifiquement, le
l'objet doit implémenter l'interface Runnable.

Il y a deux façons de créer un thread. La première consiste à déclarer une classe qui étend Thread. Quand
la classe est instanciée, le thread et l'objet sont créés ensemble et l'objet est
lié automatiquement au fil d'exécution. En appelant la méthode start() de l'objet, le fil est démarré
et appelle immédiatement la méthode run() de l'objet. Voici un exemple de code pour démontrer cela
méthode.
// Cette classe étend Thread
classe BasicThread1 étend Thread {
// Cette méthode est appelée lorsque le thread s'exécute
public void run() {
}
Classe : [Link](I.T) SEM - IV Sujet : Java de base

}
// Créer et démarrer le thread
Thread fil = nouveau BasicThread1();
[Link]();
La deuxième façon est de créer le thread et de lui fournir un objet avec une méthode run(). Cet objet
sera définitivement associé au fil. La méthode run() de l'objet sera invoquée lorsque
le fil est démarré. Cette méthode de création de fil est utile si vous voulez que plusieurs fils partagent
un objet. Voici un exemple qui crée un objet Runnable puis crée un fil avec le
objet.

class BasicThread2 implémente Runnable {

// Cette méthode est appelée lorsque le thread s'exécute
public void run() {
}
}
// Créer l'objet avec la méthode run()
Runnable runnable = new BasicThread2();

// Créez le thread en lui fournissant l'objet exécutable

Thread thread = new Thread(runnable);

// Démarrer le fil
[Link]();

classe publique MyThread étend Thread {

/**
Cette méthode est exécutée lorsque la méthode start() est appelée sur le thread.
* donc ici vous mettrez le 'code de fil'.
*/
public void run() {
[Link]("Fil exécuté !");
}

/**
* @param args les arguments de la ligne de commande
*/
public static void main(String[] args) {
Fil thread = nouveau MyThread();
Classe : [Link](I.T) SEM - IV Sujet : Core Java

fil.démarrer();
}
}

Implémentation de l'interface Runnable :

classe publique MyRunnable implémente Runnable {

/**
* Comme dans l'exemple précédent, cette méthode est exécutée
* lorsque la méthode start() est appelée sur le thread
* donc ici vous allez mettre le 'code de fil'.
*/
public void run() {
[Link]("Fil exécuté !");
}

/**
* @param args les arguments de la ligne de commande
*/
public static void main(String[] args) {

//créer un objet Thread et lui passer un objet de type Runnable

Thread thread = new Thread(new MyRunnable());
[Link]();
}
}

Arrêter un fil
La manière appropriée d'arrêter un thread en cours d'exécution est de définir une variable que le thread vérifie occasionnellement.

Lorsque le fil détecte que la variable est définie, il doit retourner depuis la méthode run().
Remarque : [Link]() et [Link]() fournissent des méthodes asynchrones pour arrêter un fil.
Cependant, ces méthodes ont été déclarées obsolètes car elles sont très dangereuses. Les utiliser
souvent entraîne des blocages et un nettoyage incorrect des ressources.
// Créer et démarrer le fil
MyThread thread = new MyThread();
[Link]();
Classe : [Link](I.T) SEM - IV Sujet : Java de base

// Arrêter le thread
[Link] = true;

classe MyThread étend Thread {

boolean toutFait = false;

// Cette méthode est appelée lorsque le thread s'exécute

public void run() {
tant que (vrai) {
si (toutFait) {
retour;
}
}
}
}
Cycle de vie d'un fil
Lorsque vous programmez avec des threads, comprendre le cycle de vie d'un thread est très
précieux. Lorsqu'un fil est actif, il est dans l'un des plusieurs états. En invoquant la méthode start(), il
ne signifie pas que le thread a accès au CPU et commence à s'exécuter immédiatement. Plusieurs
des facteurs déterminent comment cela progressera.
Classe : [Link](I.T) SEM - IV Subject : Core Java

Les différents états d'un fil sont :

Nouvel état–Après la création de l'instance Thread, le thread est dans cet état mais avant le
L'invocation de la méthode start() est considérée à ce stade comme un fil non vivant.

État exécutable (prêt à s'exécuter) - Un thread commence sa vie dans l'état exécutable. Un thread entre d'abord
l'état exécutable après l'appel de la méthode start() mais un fil d'exécution peut revenir à cet état après
soit en cours d'exécution, en attente, en train de dormir ou revenant d'un état bloqué également. Dans cet état, un fil
attend son tour sur le processeur.

État d'exécution - Un thread est dans l'état d'exécution ce qui signifie que le thread est actuellement en cours d'exécution.
Il existe plusieurs façons d'entrer dans l'état Runnable, mais il n'y a qu'un seul moyen d'entrer dans l'état Running :
le planificateur sélectionne un fil d'exécution dans le pool des threads exécutables.

État mort – Un fil peut être considéré comme mort lorsque sa méthode run() se termine. Si un fil quelconque
vient à cet état, cela signifie qu'il ne peut jamais fonctionner à nouveau.

Bloqué - Un thread peut entrer dans cet état en raison de l'attente des ressources détenues par
un autre fil.
Classe : [Link](I.T) SEM - IV Sujet : Java de base

Comme nous l'avons vu, différents états peuvent se produire avec un seul fil.
Un thread en cours d'exécution peut entrer dans n'importe quel état non exécutable, en fonction des circonstances.
Un fil ne peut pas entrer directement dans l'état d'exécution depuis l'état non exécutable, d'abord il
passe à l'état exécutable. Maintenant, comprenons certains états non exécutables qui peuvent
être en mesure de gérer les multithreads.
Dormant - Dans cet état, le fil est toujours actif mais n'est pas exécutable, il pourrait revenir.
dans un état exécutable plus tard, si un événement particulier se produit. Dans cet état, un fil s'endort pendant un
une durée spécifiée. Vous pouvez utiliser la méthode sleep( ) pour arrêter l'état d'exécution d'un
fil.

static void dormir(long millisecondes) throws InterruptedException

Attente de notification – Un fil d'exécution attend une notification d'un autre fil. Le fil envoie
retour à l'état exécutable après avoir envoyé une notification depuis un autre thread.

final void wait(long timeout) throws InterruptedException

final void attendre(long délai, int nanosecondes) jette InterruptedException
final void attendre() jette InterruptedException

Bloqué sur I/O - Le fil attend la fin de l'opération bloquante. Un fil peut entrer sur
cet état en raison de l'attente des ressources d'entrée/sortie. Dans ce cas, le thread renvoie à l'état exécutable
après la disponibilité des ressources.

Bloqué pour achèvement conjoint – Le fil peut atteindre cet état en raison de l'attente de
achèvement d'un autre fil.

Bloqué pour acquisition de verrouillage – Le thread peut se retrouver dans cet état en raison d'une attente pour acquérir

le verrou d'un objet.

Les méthodes qui peuvent être appliquées sur une classe Thread :

filActuel( ) Fil Renvoie une référence d'objet au thread dans lequel il se trouve.
invoqué.
String obtenirNom( ) Récupérer le nom de l'objet ou de l'instance de thread.
Début vide() Démarrez le fil en appelant sa méthode run.
Void run( ) Cette méthode est le point d'entrée pour exécuter un thread, comme la méthode main.
pour les applications.
Classe : [Link](I.T) SEM - IV Subject : Core Java

vide dormir( ) Suspend un fil pendant une durée spécifiée (en millisecondes).
Booléen estVivant() Cette méthode est utilisée pour déterminer si le thread est en cours d'exécution ou non.

int compterActif( ) Cette méthode renvoie le nombre de threads actifs dans un particulier
fil
groupe et tous ses sous-groupes.
interrompre(void) La méthode interrompt les fils sur lesquels elle est invoquée.
void yield( ) En invoquant cette méthode, le thread en cours interrompt temporairement son exécution.
et
permettre à d'autres threads de s'exécuter.

void join() :-
Cette méthode et join(long millisec) lancent InterruptedException. Ces deux méthodes sont
invoked on a thread. These are not returned until either the thread has completed or it is timed
respectivement.
Thread Priority :-
Comme mentionné, vous pouvez appeler la méthode interrupt() d'un objet Thread pour interrompre le
fil correspondant s'il est en sommeil ou en attente.
Le fil correspondant se "réveillera" avec une IOException à un moment donné dans le
avenir. Voir l'interruption de thread pour plus de détails.
setPriority() / getPriority()

Définit et interroge une attribution de priorité spécifique à la plateforme pour le thread donné.
Lors du calcul d'une valeur de priorité, il est bon de le faire toujours par rapport à la
les constantes Thread.MIN_PRIORITY, Thread.NORM_PRIORITY et Thread.MAX_PRIORITY.
En pratique, les valeurs vont de 1 à 10 et se rapportent à un certain intervalle spécifique à la machine.
valeurs : bonnes valeurs dans le cas de Linux, et priorités de threads locales dans le cas de
Fenêtres.
Voici généralement la plage de valeurs des fils d'utilisateurs "normaux", et le système d'exploitation va
en fait, exécutez toujours d'autres fils au-delà de ces valeurs (donc, par exemple, vous ne pouvez pas prêter
le fil du pointeur de la souris en définissant un fil à MAX_PRIORITY!).

Trois problèmes principaux concernant les priorités des threads sont que :

Leur comportement dépend de la plateforme et de la version de Java : par exemple, sous Linux,
les priorités ne fonctionnent pas du tout dans Hotspot avant Java 6, et le mappage de Java
les priorités du système d'exploitation ont changé sous Windows entre Java 5 et Java 6;

En essayant de les utiliser à des fins spécifiques, vous pourriez en réalité interférer avec davantage.
des décisions de planification sensées que le système d'exploitation aurait de toute façon prises pour

atteindre votre objectif.

Priorités des fils d'exécution
Classe : [Link](I.T) SEM - IV Objet : Java de base

En Java, le planificateur de threads peut utiliser les priorités de threads sous la forme d'une valeur entière pour chacun de ses

fil pour déterminer le calendrier d'exécution des fils. Le fil passe à l'état prêt à s'exécuter.
selon leurs priorités. Le planificateur de threads attribue le temps CPU au thread ayant la priorité la plus élevée
priorité pendant l'état prêt à l'exécution.

Les priorités sont des valeurs entières à partir de 1 (priorité la plus basse donnée par la constante

Thread.MIN_PRIORITY) à 10 (priorité la plus élevée donnée par la constante Thread.MAX_PRIORITY).

La priorité par défaut est 5 (Thread.NORM_PRIORITY).

Constant Description
Thread.MIN_PRIORITY La priorité maximale de tout thread (une valeur entière de 10)
Thread.MAX_PRIORITY La priorité minimale de tout thread (une valeur entière de 1)
Thread.NORM_PRIORITY La priorité normale de tout thread (une valeur int de 5)

Les méthodes qui sont utilisées pour définir la priorité des threads sont les suivantes :

Description de la méthode

setPriority() This is method is used to set the priority of thread.

getPriority() Cette méthode est utilisée pour obtenir la priorité du thread.

Lorsqu'un thread Java est créé, il hérite de sa priorité du thread qui l'a créé. À tout moment
à un moment donné, lorsque plusieurs threads sont prêts à être exécutés, le système d'exécution choisit le
fil exécutable avec la priorité la plus élevée pour l'exécution. Dans le système d'exécution Java, préemptif
un algorithme de planification est appliqué. Si à l'heure d'exécution, un fil d'exécution avec une priorité plus élevée et tous
d'autres fils sont exécutables alors le système d'exécution choisit le nouveau fil de priorité supérieure pour
exécution. D'autre part, si deux fils d'exécution de la même priorité attendent d'être exécutés par
le CPU puis l'algorithme du tourniquet est appliqué dans lequel le planificateur en choisit un parmi eux
s'exécuter selon leur tranche horaire.

Planificateur de fils d'exécution

Dans la mise en œuvre d'un ordonnanceur de threads, on applique généralement l'un des deux suivants.
stratégies :
Planification préemptive - Si le nouveau fil a une priorité plus élevée que celui qui est en cours d'exécution
le fil quitte l'état exécutable et un fil de priorité supérieure entre dans l'état exécutable.
Classe : [Link](I.T) SEM - IV Subject : Core Java

Planification par tranches temporelles (Tourniquet) - Un thread en cours d'exécution est autorisé à s'exécuter pendant

le temps fixe, après l'achèvement du temps, le fil actuel indique à un autre fil
pour le mettre dans un état exécutable.
Vous pouvez également définir la priorité d'un fil à tout moment après sa création en utilisant la méthode setPriority.
méthode. Voyons comment définir et obtenir la priorité d'un thread.

class MyThread1 étend Thread{

MyThread1(String s){
super(s);
commencer();
}
public void run(){
pour(int i=0;i<3;i++){
Fil cur=[Link]();
[Link](Thread.MIN_PRIORITY);
int p=[Link]();
[Link]("Nom du fil :" + [Link]().getName());
[Link]("Priorité du fil :" + cur);
}
}
}
classe MyThread2 étend Thread{
MonFil2(String s){
super(s);
début();
}

public void run(){

pour(int i=0;i<3;i++){
Fil cur=[Link]();
[Link](Thread.MAX_PRIORITY);
int p=[Link]();
[Link]("Nom du fil :" + [Link]().getName());
[Link]("Priorité du thread :" + cur);
}
}
}
classe publique ThreadPriority{
public static void main(String args[]){
Classe : [Link](I.T) SEM - IV Subject : Core Java

MyThread1 m1=new MyThread1("Mon Fil 1");

MyThread2 m2=new MyThread2("Mon Thread 2");
}
}
Sortie du programme :
C:\nisha>javac [Link]
C:\nisha>java PrioritéDeFil
Thread Name :My Thread 1
Thread Name :My Thread 2
Thread Priority :Thread[My Thread 2,10,main]
Thread Name :My Thread 2
Thread Priority :Thread[My Thread 2,10,main]
Thread Name :My Thread 2
Priorité du fil : Fil[Mon Fil 2,10,principal]
Thread Priority :Thread[My Thread 1,1,main]
Thread Name :My Thread 1
Priorité du fil : Fil[Mon Fil 1,1,principal]
Thread Name :My Thread 1
Thread Priority :Thread[My Thread 1,1,main]
Dans ce programme, deux fils sont créés. Nous avons défini une priorité maximale pour le premier fil.
"MyThread2" et priorité minimale pour le premier thread "MyThread1", c'est-à-dire après l'exécution
le programme, le premier fil s'exécute une seule fois et le second fil "MyThread2" a démarré
s'exécuter jusqu'à ce qu'il atteigne la fin ou qu'un autre thread de priorité égale soit prêt à s'exécuter.
Synchronization:-
Le langage de programmation Java fournit deux idiomes de synchronisation de base : synchronisé
méthodes et instructions synchronisées. Le plus complexe des deux, synchronisé
Les déclarations sont décrites dans la section suivante. Cette section concerne les méthodes synchronisées.

Pour rendre une méthode synchronisée, il suffit d'ajouter le mot-clé synchronized à sa déclaration :

classe publique CompteurSynchronisé {

private int c = 0;

public synchronized void increment() {

c++
}

public synchronized void decrementer() {

Classe : [Link](I.T) SEM - IV Subject : Core Java

c--;
}

public synchronized int valeur() {

retourner c;
}
}
Si count est une instance de SynchronizedCounter, alors rendre ces méthodes synchronisées a
deux effets :
Tout d'abord, il n'est pas possible que deux invocations de méthodes synchronisées sur le même objet
intercaler. Lorsque un fil d'exécution exécute une méthode synchronisée pour un objet, tous les autres
les fils qui invoquent des méthodes synchronisées pour le même objet bloquent (suspendent l'exécution) jusqu'à
le premier fil est fait avec l'objet.
Deuxièmement, lorsqu'une méthode synchronisée sort, elle établit automatiquement un happen-before.
relation avec toute invocation subséquente d'une méthode synchronisée pour le même objet.
Cela garantit que les modifications de l'état de l'objet sont visibles par tous les threads.

Notez que les constructeurs ne peuvent pas être synchronisés - l'utilisation du mot-clé synchronized avec un
Le constructeur est une erreur de syntaxe. Synchroniser les constructeurs n'a pas de sens, car seul le
Le fil qui crée un objet devrait y avoir accès pendant sa construction.
Avertissement : Lors de la construction d'un objet qui sera partagé entre des threads, soyez très prudent
qu'une référence à l'objet ne 'fuit' pas prématurément. Par exemple, supposons que vous vouliez
maintenez une liste appelée instances contenant chaque instance de la classe. Vous pourriez être tenté d'ajouter
la ligne
[Link](this);
à votre constructeur. Mais ensuite, d'autres threads peuvent utiliser des instances pour accéder à l'objet avant
la construction de l'objet est terminée.

Les méthodes synchronisées permettent une stratégie simple pour prévenir l'interférence des threads et
erreurs de cohérence de la mémoire : si un objet est visible par plus d'un thread, toutes les lectures ou écritures vers
les variables de cet objet sont gérées par des méthodes synchronisées. (Une exception importante : final
les champs, qui ne peuvent être modifiés une fois l'objet construit, peuvent être lus en toute sécurité à travers
méthodes non synchronisées, une fois que l'objet est construit) Cette stratégie est efficace, mais peut
présenter des problèmes de vivacité, comme nous le verrons plus tard dans cette leçon.

Au lieu de laisser les programmeurs concevoir leurs propres verrous, gérer les blocs de synchronisation,
et applique les règles de synchronisation, Java offre un moniteur de synchronisation sur chaque instance de
Classe : [Link](I.T) SEM - IV Sujet : Java de base

la classe Object, afin qu'elle puisse être utilisée comme un verrou de synchronisation. Puisque toutes les classes sont des sous-classes de
Objet, tous les objets en Java peuvent être utilisés comme verrous de synchronisation.

Java offre également trois manières de définir des blocs synchronisés.

Méthode de classe synchronisée :

classe nom_de_classe {
méthode statique synchronisée type nom_méthode() {
bloc de déclaration
}
}

Toutes les instructions de la méthode deviennent le bloc synchronisé, et l'objet de la classe est le
verrou
Méthode d'instance synchronisée :
classe nom_de_classe {
synchronized type méthode_nom() {
bloc de déclaration
}
}
Toutes les instructions de la méthode deviennent le bloc synchronisé, et l'objet d'instance est le
fermer
Instruction synchronisée :
classe nom_de_classe {
type method_name() {
synchronisé (objet) {
bloc d'instructions
}}}
Classe : [Link](I.T) SEM - IV Subject : Core Java

11 - Forfaits

Un paquet Java est un mécanisme pour organiser les classes Java en espaces de noms similaires à
les modules de Modula.
Les paquets Java peuvent être stockés dans des fichiers compressés appelés fichiers JAR, permettant aux classes de
téléchargez plus rapidement en groupe plutôt qu'un à la fois.
Les programmeurs utilisent également généralement des packages pour organiser les classes appartenant à la même
category or providing similar functionality.
Un package fournit un espace de noms unique pour les types qu'il contient.
Les classes du même paquet peuvent accéder aux membres d'accès au paquet des autres.

Utilisation de paquets

Dans un fichier source Java, le package auquel appartiennent la classe ou les classes de ce fichier est spécifié avec le
mot clé de package. Ce mot clé est généralement le premier mot clé dans le fichier source.

paquet [Link];

Pour utiliser les classes d'un package dans un fichier source Java, il est pratique d'importer les classes de
the package with an import declaration. The following declaration
import [Link].*;

importe toutes les classes du paquet [Link], tandis que la déclaration suivante
import [Link];

importe uniquement la classe ActionEvent du paquet. Après l'une de ces déclarations d'importation,
la classe ActionEvent peut être référencée en utilisant son nom de classe simple :
ActionEvent monÉvénement = new ActionEvent();

Les classes peuvent également être utilisées directement sans déclaration d'importation en utilisant le nom complet.
de la classe. Par exemple,
[Link] myEvent = new [Link]();
Les classes au sein d'un package peuvent accéder aux classes et aux membres déclarés avec un accès par défaut.
et les membres de classe déclarés avec le modificateur d'accès protégé.
L'accès par défaut est appliqué lorsque l'accès public, protégé ou privé n'est pas spécifié.
le modificateur est spécifié dans la déclaration.
Classe : [Link](I.T) SEM - IV Objet : Java de base

En revanche, les classes dans d'autres packages ne peuvent pas accéder aux classes et membres déclarés avec
accès par défaut.
Les membres de classe déclarés comme protégés peuvent être accessibles depuis les classes dans le même
le paquet ainsi que les classes dans d'autres paquets qui sont des sous-classes de la classe déclarée.
Conventions de nommage de paquet
Les paquets sont généralement définis en utilisant un schéma de nommage hiérarchique, avec des niveaux dans le
hierarchie séparée par des points (.) (prononcé "point").
Bien que les paquets situés plus bas dans la hiérarchie de nommage soient souvent appelés
«sous-packages» des paquets correspondants plus hauts dans la hiérarchie, il n'y a pas
relation sémantique entre les paquets.
La Spécification du Langage Java établit des conventions de nommage de paquets pour éviter le
possibilité de deux packages publiés ayant le même nom.
Les conventions de nommage décrivent comment créer des noms de paquet uniques, afin que
Les paquets largement distribués auront des espaces de noms uniques.
Cela permet aux packages d'être installés et catalogués séparément, facilement et automatiquement.
En général, un nom de paquet commence par le nom de domaine de premier niveau de l'organisation
et ensuite le domaine de l'organisation et ensuite tous les sous-domaines énumérés dans l'ordre inverse.
L'organisation peut alors choisir un nom spécifique pour son paquet. Noms de paquet
devrait être en minuscules autant que possible.
For example, if an organization in Canada called MySoft creates a package to deal with
fractions, nommant le paquet [Link] distingue le paquet fractions
d'un autre paquet similaire créé par une autre entreprise.
Si une entreprise américaine nommée MySoft crée également un paquet de fractions, mais l'appelle
[Link], puis les classes dans ces deux packages sont définies de manière unique et
espace de noms séparé.
Créer et utiliser des paquets
Pour faciliter la recherche et l'utilisation des types, éviter les conflits de noms et contrôler l'accès,
les programmeurs regroupent des types connexes dans des paquets.

Définition : Un package est un regroupement de types liés offrant une protection d'accès et
gestion des espaces de noms. Notez que les types se réfèrent aux classes, interfaces, énumérations,
et types d'annotations. Les énumérations et les types d'annotations sont des sortes spéciales de classes
et interfaces, respectivement, donc les types sont souvent simplement appelés dans cette leçon comme
classes et interfaces.
Les types qui font partie de la plateforme Java sont des membres de divers packages qui
regrouper les classes par fonction : les classes fondamentales se trouvent dans [Link], les classes pour la lecture et
L'écriture (entrée et sortie) se fait dans [Link], et ainsi de suite. Vous pouvez mettre vos types dans des paquets.

aussi.
Classe : [Link](I.T) SEM - IV Sujet : Java de base

Supposons que vous écriviez un groupe de classes qui représentent des objets graphiques, tels que des cercles,
rectangles, lignes et points. Vous écrivez également une interface, Draggable, que les classes
implémenter s'ils peuvent être déplacés avec la souris.
//dans le fichier [Link]
interface publique Déplaçable {
...
}

//dans le fichier [Link]

classe abstraite publique Graphic {
...
}

//dans le fichier [Link]

public class Cercle étend Graphique implémente Déplaçable {
...
}

//dans le fichier [Link]

public class Rectangle extends Graphic implements Draggable {
...
}

//in the [Link] file

public class Point extends Graphic implements Draggable {
...
}

//dans le fichier [Link]

public class Line extends Graphic implements Draggable {
...
}

Importation de Claass :

Ex : classe A classe B

je veux importer la classe A dans la classe B

Classe : [Link](I.T) SEM - IV Subject : Core Java

La classe B est une classe de test

La classe A se compile correctement.

Mais quand vous essayez de créer une instance de la classe A dans la classe B, cela se plaint des doublons ou
quelque chose.

paquet outils;
importer [Link].*;

classe publique Encryptor

{
Clé de chaîne;
Chaîne estring, dstring;

public Encryptor()
{}

public Encryptor(String s)
{
s = clé;

String chiffrer(String se)

{
retourner estring;
}

Chaîne décryptée(String sd)

{
retourner dstring;
}
}

classe de test de l'encryptor

Classe : [Link](I.T) SEM - IV Subject : Core Java

importer [Link].*;
import [Link].*;
import tools.*;

classe Encryptortest
{
public static void main (String []args)
lance IOException {

BufferedReader stdin = new BufferedReader

(nouveau InputStreamReader([Link]));
Encrypteur e1;
// [Link]([Link]é);
}
}
Paquets et Importation
Le package = répertoire. Les classes Java peuvent être regroupées dans des packages. Un nom de package est le
identique au nom du répertoire (dossier) qui contient les fichiers .java. Vous déclarez des packages lorsque
vous définissez votre programme Java et vous nommez les packages que vous souhaitez utiliser d'autres bibliothèques
dans une déclaration d'importation.

Déclaration de package
La première instruction, en dehors des commentaires, dans un fichier source Java, doit être le package
déclaration.
Après la déclaration de package optionnelle, vous pouvez avoir des instructions d'importation, qui permettent
pour spécifier des classes d'autres packages qui peuvent être référencées sans les qualifier avec
leur colis.

Package par défaut. Bien que toutes les classes Java se trouvent dans un répertoire, il est possible d'omettre le package.
déclaration. Pour les petits programmes, il est courant de l'ommettre, auquel cas Java crée ce qu'il appelle un
package par défaut. Sun recommande de ne pas utiliser de packages par défaut.
Syntaxe de déclaration de paquet

L'ordre des déclarations est le suivant. Les commentaires peuvent être placés n'importe où.

Déclaration de paquet (optionnel).

Imports (facultatif).
Définitions de classe ou d'interface.
// Ce fichier source doit être [Link] dans le répertoire d'illustration.

Package1([Link])
Classe : [Link](I.T) SEM - IV Sujet : Java de base

package area;
classe publique RectA
{
double a;

public RectA(double len,double brd)

{

a=len*brd;
}

public void montrer()

{
[Link]("La superficie du rectangle est :" + a);
}
}

Paquet 2([Link])
package zone;
classe publique cercleA
{
double areac,pi=3.14;

cercleA(double r)
{
aire=pi*r*r;
}
public void montrer()
{
[Link]("L'aire du cercle est : " + areac);
}
}

Classe Fichier ([Link])

importer zone.*;

classe CalArea
{
Classe : [Link](I.T) SEM - IV Sujet : Java de base

public static void main(String args[])

{
circleA c=new circleA(1f);
RectA r = new RectA(3f,4f);
[Link]();
[Link]();
}
}

Tout d'abord, compilez tous les fichiers de package

Alors fais ça

Paquet [Link]
Cours de mathématiques

1) random()
2) arrondir()
3) pow()
4) racine carrée()

5) abs()
max()
7) log()
Classe : [Link](I.T) SEM - IV Subject : Core Java

import [Link].*;
classe MathClassDemo
{
public static void main(String args[])
{

double rand = [Link]();

[Link]("Nombre aléatoire="+rand);
double f = 3.6;
double rund = [Link](f);
[Link]("Round Value="+rund);
[Link]([Link](24,2));

[Link]("Racine carrée="+[Link](11));
int num = -3;
[Link]("Valeur Absolue="+[Link](num));

[Link]("Valeur Maximum="+[Link](10.22,10.33));
[Link]("Log value="+[Link](10));

}
}