La anotación @Deprecated en Java

La anotación @Deprecated le dice al compilador que un método, clase o campo está en desuso y que debe generar una advertencia si alguien intenta usarlo. Eso es lo que es una clase o método en desuso. Ya no es relevante. Es tan poco importante que debe dejar de usarlo porque ha sido reemplazado y puede eliminarse gradualmente en el futuro.

Una clase o método en desuso es así. Ya no es importante. Es tan poco importante, de hecho, que ya no debería usarlo ya que ha sido reemplazado y puede dejar de existir en el futuro. Debido a que la API (interfaz de programación de aplicaciones) de una clase cambia con el tiempo, Java proporciona una forma de expresar el desuso. Se cambia el nombre de los métodos para mantener la coherencia, se agregan métodos nuevos y mejores y se modifican los campos. Sin embargo, tales cambios plantean un problema. Si necesita mantener la API anterior hasta que los desarrolladores hagan la transición a la nueva, pero no quiere que continúen programando contra ella, puede usar la anotación integrada para desaprobar el elemento.

Ahora, el uso de la anotación @Depricated se muestra a continuación: La API de un proyecto evoluciona con el tiempo. No queremos que la gente siga usando ciertos constructores, campos, tipos o métodos a medida que pasa el tiempo. En lugar de romper la compatibilidad con versiones anteriores de la API del proyecto, podemos usar la anotación @Deprecated para marcar estos elementos como obsoletos. @Deprecated indica a otros desarrolladores que se debe evitar el elemento marcado.

Con Java 9, se realizan dos nuevas mejoras en la anotación @Deprecated:

• forRemoval : indica si el elemento anotado está sujeto a eliminación en una versión futura. El valor predeterminado es falso.
• since : Devuelve la versión en la que el elemento anotado quedó obsoleto. El valor predeterminado es la string vacía.

¿Cómo depreciar?

1. A través de la interfaz obsoleta
2. A través de la clase en desuso
3. A través de Deprecating a method
4. A través de la desaprobación de una variable miembro
5. A través de la desaprobación de un constructor

Usamos la anotación @Deprecated para desaprobar un método, clase o campo, y la etiqueta @deprecated Javadoc en la sección de comentarios para informar al desarrollador sobre el motivo de la desaprobación y qué se puede usar en su lugar.

1. Interfaz en desuso:

@Deprecated

interface GFG {
  // Interface methods
}

2. Clase en desuso

@Deprecated

class GFG {
// Class implementation
}

3. Desaprobar un método

class GFG {

  @Deprecated

  // old method
  public void gfgmethod() {}

  // new, alternate method
  public void gfgmethod2() {}
}

4. Obsolescencia de una variable miembro

class GFG {
  
  @Deprecated
  
  public static final int MAX_SIZE  = 1024;
  // new, alternate field
  public static final int MAX_UPLOAD_SIZE = 1024;
}

5. Desaprobación de un constructor

class GFG {

  @Deprecated
  
  Gfg(String name, int length, int width) {

  }
  
  // new, alternate constructor
  Gfg(Style style) {

  }
}

Implementación: Ahora permítanos implementarlos con un programa Java limpio para el mismo.

Ejemplo 1: uso de nombre de variable en desuso .

// Java Program Illustrating The @Deprecated Annotation
// Using deprecated variable name
  
// Main class
public class GFG {
  
    // @deprecated number1 will be replaced by
    // newnum field
    @Deprecated
  
    // Declaring and initializing integer variables
    int number = 100;
    // New field
    final int newnumber = 100;
  
    // Main
    public static void main(String a[])
    {
        // Creating an object for the class
        GFG obj = new GFG();
  
        // Printing the number
        System.out.println(obj.number);
    }
}

100

Ejemplo 2: uso de un nombre de método en desuso.

// Java Program Illustrating The @Deprecated Annotation
// Using deprecated method name
  
// Main class
public class GFG {
  
    // @deprecated The function oldmethod will be replaced
    //  by new method
    @Deprecated
  
    // Method 1
    // Old method
    public void oldmethod()
    {
  
        // Print statement
        System.out.println("This is a deprecated method");
    }
  
    // Method 2
    // New method
    public void newmethod(String m1)
    {
  
        // Print statement
        System.out.println(m1);
    }
  
    // Method 3
    // Main driver method
    public static void main(String a[])
    {
  
        // Creating an object of class
        GFG obj = new GFG();
  
        // Now calling the old method
        obj.oldmethod();
    }
}

This is a deprecated method

Ejemplo 3: uso del nombre de método en desuso, así como el nombre de variable en desuso.

// Java Program Illustrating The @Deprecated Annotation
// Using deprecated method name
// as well as the deprecated variable name
  
// Main class
class GFG {
  
    // @deprecated
    // The old function will be replaced by new one
    @Deprecated
  
    // Declaring and initializing integer values
    int no = 10;
    final int MAX_NUM = 100;
  
    @Deprecated
  
    // Method 1
    // Old method
    public void gfgMsg()
    {
  
        // Print statement
        System.out.println("This method is deprecated");
    }
  
    // Method 2
    // New Method
    public void gfgMsg2(String msg, String msg2)
    {
  
        // Print statement
        System.out.println(msg + msg2);
    }
  
    // Method 3
    // Main driver method
    public static void main(String a[])
    {
  
        // Creating an object of class
        GFG obj = new GFG();
  
        // Now calling the old method
        obj.gfgMsg();
  
        // Printing the num
        System.out.println(obj.no);
    }
}

This method is deprecated
10

Ejemplo 4: usar un constructor en desuso y el nombre de la variable en desuso.

// Java Program Illustrating The @Deprecated Annotation
// Using deprecated constructor
// as well as the deprecated variable name.
  
// Main class
public class GFG {
  
    // @deprecated
    // The field number will be replaced by newnumber field
    @Deprecated
  
    int number = 10;
  
    // new field
    final static int newnumber = 10;
  
    // @deprecated
    // The constructor depexamplewill be replaced by second
    // depexample
  
    // Old constructor
    GFG(int a, int b, int c)
    {
  
        // Print statement for old constructor
        System.out.println(
            "This is a deprecated constructor");
    }
  
    // new constructor
    GFG(float d, int e, float f)
    {
  
        // Print statement for new constructor
        System.out.println(d + f);
    }
  
    // Main driver method
    public static void main(String a[])
    {
  
        // Creating object of class
        GFG obj = new GFG(newnumber, newnumber, newnumber);
  
        // Print and display the number
        System.out.println(obj.number);
    }
}

This is a deprecated constructor
10