@obsolète en Java

En Java, @Deprecated est une annotation qui aide à informer le compilateur que la classe, la méthode ou le champ spécifique n'est plus utilisé car il a cessé ou est remplacé. De plus, un avertissement doit être donné lorsque quelqu’un essaie de l’utiliser. Le principal avantage de la dépréciation réside dans le cas où des méthodes sont renommées ou ajoutées, des changements se produisent. Comme cela peut affecter le fonctionnement du programme, les annotations obsolètes sont devenues très utiles. La syntaxe, le fonctionnement et l'exemple d'annotation @deprecated seront abordés dans les sections suivantes.

PUBLICITÉ Cours populaire dans cette catégorie MODÉLISATION ET VALORISATION FINANCIÈRE - Spécialisation | 51 Série de cours | 30 tests simulés

Commencez votre cours de développement de logiciels libres

Développement Web, langages de programmation, tests de logiciels et autres

Syntaxe de Java @annotation obsolète

@deprecated peut être utilisé dans les classes, les interfaces, les méthodes, les variables membres, les constructeurs, etc. Voyons chacun d'eux en détail.

1. Syntaxe de dépréciation de l'interface

@deprecated
interface sample
{
//methods of the interface
.... .
}

2. Syntaxe de dépréciation de classe :

@deprecated
class sample
{
//implementation of the class sample
. . . . .
}

3. Syntaxe de dépréciation de méthode

@deprecated
class sample
{
@deprecated
Public void samplemethod1()
{
//implementation of the old samplemethod
. . . . .
}
Public void samplemethod2()
{
//implementation of the newsamplemethod
. . . . .
}
}

4. Syntaxe d'amortissement des variables membres

class sample
{
@deprecated
//old field
Public static final float PI=3.14
// new field
Public static final float PI_VALUE=3.14
}

5. Syntaxe de dépréciation du constructeur

class sample
{
@deprecated
sample(int a, int b, int c)
{
//implementation of the old constructor
. . . . .
}
sample(intd)
{
//implementation of the new constructor
. . . . .
}
}

Comment @deprecated fonctionne en Java ?

Comme déjà évoqué, la dépréciation d'une méthode, d'un champ ou d'une classe se fait à l'aide de l'annotation @deprecated. De plus, pour avertir le développeur, la balise java doc @deprecated sera incluse dans la section commentaire avec la modification.

Vous trouverez ci-dessous quelques-uns des contextes courants dans lesquels cette annotation est utilisée.

• Déclaration des constructeurs
• Déclaration du paramètre formel
• Déclaration de classe
• Déclaration de colis
• Déclaration de méthode
• Déclaration de variable locale
• Déclaration de terrain
• Déclaration d'interface
• Déclaration d'énumération

Remarque :

Le compilateur n'émettra pas d'avertissement obsolète dans les cas tels que :

• Si un élément obsolète est utilisé par un autre élément qui est obsolète. Autrement dit, une classe obsolète appelle un constructeur obsolète.
• Si l'élément obsolète est utilisé dans une entité qui a une annotation @SuppressWarnings("deprecation").
• Si l'élément obsolète est déclaré et utilisé dans la même classe la plus externe.

Exemples de @deprecated en Java

Voyons quelques-uns des programmes obsolètes en Java. Lors de l'écriture de programmes, assurez-vous toujours d'utiliser @Deprecated pour la dépréciation et @deprecated à des fins de documentation.

Exemple n°1

Utilise un nom de variable obsolète.

Code :

public class depexample {
/* @deprecated The field num1 will be replaced by
* newnum field
*/
@Deprecated
int num1 = 10;
//new field
final int newnum = 10;
public static void main(String a[]){
//create an object for the class
depexample obj = new depexample();
//print num
System.out.println(obj.num1);
}
}

Exemple de sortie

Dans ce programme, une variable num1 est obsolète, et un Newnum est également déclaré pour être utilisé à la place de num1. Ainsi, lors de l'exécution de ce programme, la valeur 10 est imprimée.

Exemple n°2

Utilise un nom de méthode obsolète.

Code :

public class depexample {
/* @deprecated The function method1 will be replaced by method2
*/
@Deprecated
//old method
public void method1(){
System.out.println("This is a deprecated method");
}
//new method
public void method2(String m1, String m2){
System.out.println(m1+m2);
}
public static void main(String a[]){
//class object
depexample obj = new depexample();
//call old method
obj.method1();
}}

Exemple de sortie

Dans ce programme, une méthode nommée méthode1 est obsolète et une autre méthode nommée méthode2 est déclarée comme étant utilisée à la place de méthode1. Ainsi, lors de l'exécution de ce programme, la ligne est imprimée.

Exemple #3

Utilise un nom de méthode obsolète ainsi que le nom de variable obsolète.

Code :

public class depexample {
/* @deprecated The field num1 will be replaced by
* newnum field
*/
@Deprecated
int num1 = 10;
//new field
final int newnum=10;
/* @deprecated The function method1 will be replaced by method2
*/
//old method
public void method1(){
System.out.println("This is a deprecated method");
}
//new method
public void method2(String m1, String m2){
System.out.println(m1+m2);
}
public static void main(String a[]){
//class object
depexample obj = new depexample();
//call old method
obj.method1();
//print num
System.out.println(obj.num1);
}
}

Exemple de sortie

Dans ce programme, les deux premiers programmes sont combinés de telle sorte qu'une variable num1 est obsolète et qu'un Newnum est également déclaré comme étant utilisé à la place de num1. De plus, une méthode nommée méthode1 est obsolète et une autre méthode nommée méthode2 est déclarée comme étant utilisée à la place de méthode1.  Ainsi, lors de l'exécution de ce programme, la valeur 10 et une ligne sont imprimées.

Exemple n°4

Utilise un constructeur obsolète ainsi que le nom de variable obsolète.

Code :

public class depexample {
/* @deprecated The field num1 will be replaced by
* newnum field
*/
@Deprecated
int num1=10;
//new field
final static int newnum=10;
/* @deprecated The constructor depexamplewill be replaced by second depexample
*/
//old constructor
depexample(int a, int b, int c){
System.out.println("This is a deprecated method");
}
//new constructor
depexample(float d, int e, float f){
System.out.println(d+f);
}
public static void main(String a[]){
//class object
depexample obj = new depexample(newnum, newnum, newnum);
//print num
System.out.println(obj.num1);
}}

Exemple de sortie

Dans ce programme, une variable num1 est obsolète, et un Newnum est également déclaré pour être utilisé à la place de num1. De plus, le constructeur déclaré en premier est également obsolète et le deuxième constructeur est déclaré comme étant utilisé à la place du premier constructeur.  Ainsi, lors de l'exécution de ce programme, la valeur 10 et une ligne sont imprimées.

Conclusion

Grâce à cet article, vous pourrez comprendre ce qu'est la dépréciation et les différentes situations dans lesquelles plusieurs utilisateurs peuvent l'utiliser. En plus de cela, la syntaxe, le fonctionnement, des exemples d'annotation @Deprecated sont également abordés, ainsi que des extraits de code de travail et des exemples de sorties.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!