Compatibilidad con versiones anteriores en un sistema de software con referencia sistemática a Java

Aquí discutiremos una forma de lograr la «Compatibilidad con versiones anteriores» mientras desarrollamos nuevas funciones en cualquier sistema de software. Así que hagamos un breve resumen sobre la compatibilidad con versiones anteriores. La compatibilidad con versiones anteriores es una propiedad de un sistema, producto o tecnología que permite la integración con un sistema heredado más antiguo o con una entrada diseñada para dicho sistema. La modificación de un sistema de una manera que no permite la compatibilidad con versiones anteriores se denomina «cambio radical». Si bien la era actual de desarrollo de software ágil exige una implementación acelerada de funciones para satisfacer los requisitos que cambian rápidamente, es extremadamente necesario tener compatibilidad con versiones anteriores en el software que se está desarrollando.

Aquí discutiremos cómo Java ha logrado la compatibilidad con versiones anteriores al desarrollar nuevas funciones, que servirán como referencia potencial al actualizar el código existente. 

Ahora comprendamos el concepto muy importante de ‘ ampliación ‘ y cómo se retiene mientras se desarrollan nuevas características como Autoboxing en Java 5. En una clase que tiene métodos sobrecargados, uno de los trabajos del compilador es determinar qué método usar cada vez que encuentra una invocación para el método sobrecargado.

Ejemplo 1:

// Java Program to Without Involving Concepts
// of Java 5 Features
 
// Importing required classes
import java.io.*;
 
// Main class
// To test method overloading
class GFG {
 
    // Method 1
    static void print(int i)
    {
        // Print statement when method 1 is called
        System.out.println("int = " + i);
    }
 
    // Method 2
    static void print(long l)
    {
        // Print statement when method 2 is called
        System.out.println("long = " + l);
    }
 
    // Method 3
    static void print(double d)
    {
        // Print statement when method 3 is called
        System.out.println("double = " + d);
    }
 
    // Method 4
    // Main driver method
    public static void main(String[] args)
    {
        // Declaring and initializing variables
        byte b = 5;
        short s = 5;
        long l = 5;
        float f = 5.0f;
 
        // Calling the methods
        print(b);
        print(s);
        print(l);
        print(f);
    }
}

int = 5
int = 5
long = 5
double = 5.0

Cuando se invoca un método con byte y los argumentos cortos , el compilador de Java lo amplía implícitamente para que coincida con la versión adecuada del método print() que acepta un argumento int. Además, como se puede ver, cuando se invoca un método de impresión con long , utiliza versiones respectivas del método de impresión print(long l) y la llamada al método que usa un flotante se compara con el método que toma un doble y, por lo tanto, en a su vez, explicando el comportamiento de la ampliación .


Nota: cuando no se encuentra una coincidencia exacta, la JVM usa el método con el argumento más pequeño posible que es más ancho que el parámetro que se pasa.

Ejemplo 2: Aquí tendremos solo un método que acepta el doble como argumento. Cuando se invoca con byte, short, long y float , coincidirá con las cuatro invocaciones del método  print()

// Main class
// To test Method Overloading
class TestMethodOverloading {
     
    static void print(double d)
    {
        System.out.println("double = " + d);
    }
    public static void main(String[] args)
    {
        byte b = 5;
        short s = 5;
        long l = 5;
        float f = 5.0f;
        print(b);
        print(s);
        print(l);
        print(f);
    }
}

double = 5.0
double = 5.0
double = 5.0
double = 5.0

Ahora analicemos nuestra característica en Java5 que es el autoboxing. Autoboxing fue una de las características clave que se introdujeron en Java 5. Autoboxing es la conversión automática que realiza el compilador de Java entre los tipos primitivos y sus correspondientes clases contenedoras de objetos. Por ejemplo, convertir un int en un número entero, un doble en un doble, etc. Así que ponga en juego el concepto de compatibilidad con versiones anteriores de Java 5. Con referencia a Autoboxing, considere el siguiente ejemplo que nos ayudará a comprender cómo Java mantiene la compatibilidad con versiones anteriores al tiempo que introduce nuevas funciones.

Ejemplo 

// Java Program Illustrating Maintenance of Backward
// Compatibility
 
// Importing required classes
import java.io.*;
 
// Main class
// To test backwards compatibility
class GFG {
 
    // Method 1
    static void print(Integer i)
    {
        // Print statement whenever method 1 is called
        System.out.println("Integer = " + i);
    }
 
    // Method 2
    static void print(long l)
    {
        // Print statement whenever method 1 is called
        System.out.println("long = " + l);
    }
 
    // Method 3
    // Main driver method
    public static void main(String[] args)
    {
        int i = 5;
 
        // Calling method over above custom input
        print(i);
    }
}

long = 5

Los aprendizajes de los resultados anteriores son los siguientes:

• Si existiera la única versión del método print() que acepta un Integer , entonces con referencia a la capacidad Autoboxing de Java 5, la invocación de print() sería exitosa. De manera similar, si solo existiera la versión larga, el compilador invoca la misma.
• ¿Y si existen ambos métodos, cuál se utilizará? Entonces, para establecer la compatibilidad de backwoods, el compilador piensa que ampliar un parámetro primitivo es más deseable que realizar una operación de Autoboxing, por lo que el compilador elegirá ampliar sobre boxing y la salida será

Conclusión: en este artículo, hemos visto cómo mantener y cosas a considerar para lograr la «Compatibilidad con versiones anteriores» mientras desarrollamos nuevas funciones con el ejemplo. Los diseñadores de Java dieron preferencia a la función existente ‘Ampliación’ con la introducción de la nueva función ‘Autoboxing’ en Java 5. Una regla importante es que el código preexistente debe funcionar de la forma en que solía hacerlo, de modo que el compilador siempre elija el estilo anterior antes de elegir el estilo más nuevo (Ensanchamiento sobre Autoboxing).