"Si un trabajador quiere hacer bien su trabajo, primero debe afilar sus herramientas." - Confucio, "Las Analectas de Confucio. Lu Linggong"
Herramientas en línea
Tutoriales de software
Sitio de navegacion
Programación
Página delantera > Programación > Consejos para tratar con tipos difíciles y código heredado

Consejos para tratar con tipos difíciles y código heredado

Publicado el 2025-04-17
Navegar:931

Tipos brutos e código legado

Gross Types se introdujeron en la compatibilidad entre los códigos heredados (pregenericos) y los genéricos introducidos en JDK 5. Habilitan la transición gradual, pero comprometen tipos .

definiciones y características Tipo bruto:

    Use una clase genérica sin especificar argumentos de tipo. Ejemplo:
gen raw = new gen (new double (98.6)); // Tipo de crudo creado 
Gen raw = new Gen(new Double(98.6)); // Tipo bruto criado

Compatibilidad:

Las variables de tipo bruto pueden recibir cualquier objeto genérico y viceversa.

No hay verificación de los tipos en el tiempo de compilación, lo que resulta en posibles errores en el tiempo de ejecución.

Ejemplo de código

// clase gen con soporte genérico Gen de clase { T ob; // declara un objeto de tipo t Gen (t o) {// constructor Ob = o; } T getob () {// Devuelve el objeto OBS Regresar ob; } } // demostración de tipos brutos Clase RawDemo { Public static void main (string [] args) { // usando genéricos correctamente Gen IOB = New Gen (88); Gen strob = new Gen ("Prueba de genéricos"); // Creando un tipo bruto Gen raw = new Gen (new Double (98.6)); doble d = (doble) raw.getOb (); // funciona, pero pierde el tipo de seguridad System.out.println ("Valor:" D); // Errores de tiempo de ejecución con tipos brutos // int i = (integer) raw.getOb (); // Error de tiempo de ejecución! // Asignación de tipo bruto para genérico Estroce = crudo; // Correcto, pero peligroso // string str = strob.getob (); // Error de tiempo de ejecución! // atribución bruta genérica RAW = IOB; // Correcto, pero peligroso // d = (doble) raw.getob (); // Error de tiempo de ejecución! } } 
// Classe Gen com suporte a genéricos
class Gen {
    T ob; // Declara um objeto do tipo T

    Gen(T o) { // Construtor
        ob = o;
    }

    T getob() { // Retorna o objeto ob
        return ob;
    }
}

// Demonstração de tipos brutos
class RawDemo {
    public static void main(String[] args) {
        // Usando genéricos corretamente
        Gen iOb = new Gen(88);
        Gen strOb = new Gen("Generics Test");

        // Criando um tipo bruto
        Gen raw = new Gen(new Double(98.6));
        double d = (Double) raw.getob(); // Funciona, mas perde segurança de tipos
        System.out.println("value: "   d);

        // Erros de tempo de execução com tipos brutos
        // int i = (Integer) raw.getob(); // Erro de tempo de execução!

        // Atribuição de tipo bruto para genérico
        strOb = raw; // Correto, mas perigoso
        // String str = strOb.getob(); // Erro de tempo de execução!

        // Atribuição de genérico para tipo bruto
        raw = iOb; // Correto, mas perigoso
        // d = (Double) raw.getob(); // Erro de tempo de execução!
    }
}

Riesgos del uso de tipos brutos
falta de seguridad de tipo:

    asignar tipos brutos a genéricos o viceversa puede causar errores en el tiempo de ejecución.
ejemplos:


strob = raw; // Dangerous: Raw contiene doble, pero la estocatura espera una cadena RAW = IOB; // peligroso: Raw ahora contiene entero, pero la coerción puede fallar 
// Classe Gen com suporte a genéricos
class Gen {
    T ob; // Declara um objeto do tipo T

    Gen(T o) { // Construtor
        ob = o;
    }

    T getob() { // Retorna o objeto ob
        return ob;
    }
}

// Demonstração de tipos brutos
class RawDemo {
    public static void main(String[] args) {
        // Usando genéricos corretamente
        Gen iOb = new Gen(88);
        Gen strOb = new Gen("Generics Test");

        // Criando um tipo bruto
        Gen raw = new Gen(new Double(98.6));
        double d = (Double) raw.getob(); // Funciona, mas perde segurança de tipos
        System.out.println("value: "   d);

        // Erros de tempo de execução com tipos brutos
        // int i = (Integer) raw.getob(); // Erro de tempo de execução!

        // Atribuição de tipo bruto para genérico
        strOb = raw; // Correto, mas perigoso
        // String str = strOb.getob(); // Erro de tempo de execução!

        // Atribuição de genérico para tipo bruto
        raw = iOb; // Correto, mas perigoso
        // d = (Double) raw.getob(); // Erro de tempo de execução!
    }
}

excepciones en el tiempo de ejecución:

No hay forma de detectar inconsistencias en el tiempo de compilación.

Ejemplo:

int i = (integer) raw.getOb (); // Error por qué RAW contiene doble 
// Classe Gen com suporte a genéricos
class Gen {
    T ob; // Declara um objeto do tipo T

    Gen(T o) { // Construtor
        ob = o;
    }

    T getob() { // Retorna o objeto ob
        return ob;
    }
}

// Demonstração de tipos brutos
class RawDemo {
    public static void main(String[] args) {
        // Usando genéricos corretamente
        Gen iOb = new Gen(88);
        Gen strOb = new Gen("Generics Test");

        // Criando um tipo bruto
        Gen raw = new Gen(new Double(98.6));
        double d = (Double) raw.getob(); // Funciona, mas perde segurança de tipos
        System.out.println("value: "   d);

        // Erros de tempo de execução com tipos brutos
        // int i = (Integer) raw.getob(); // Erro de tempo de execução!

        // Atribuição de tipo bruto para genérico
        strOb = raw; // Correto, mas perigoso
        // String str = strOb.getob(); // Erro de tempo de execução!

        // Atribuição de genérico para tipo bruto
        raw = iOb; // Correto, mas perigoso
        // d = (Double) raw.getob(); // Erro de tempo de execução!
    }
}

avisos de no -verificación:

    El compilador Javac genera advertencias cuando detecta los tipos brutos utilizados inseguamente.
ejemplos que generan advertencias


gen raw = new gen (new double (98.6)); // Tipo bruto Estroce = crudo; // Asignación insegura 
// Classe Gen com suporte a genéricos
class Gen {
    T ob; // Declara um objeto do tipo T

    Gen(T o) { // Construtor
        ob = o;
    }

    T getob() { // Retorna o objeto ob
        return ob;
    }
}

// Demonstração de tipos brutos
class RawDemo {
    public static void main(String[] args) {
        // Usando genéricos corretamente
        Gen iOb = new Gen(88);
        Gen strOb = new Gen("Generics Test");

        // Criando um tipo bruto
        Gen raw = new Gen(new Double(98.6));
        double d = (Double) raw.getob(); // Funciona, mas perde segurança de tipos
        System.out.println("value: "   d);

        // Erros de tempo de execução com tipos brutos
        // int i = (Integer) raw.getob(); // Erro de tempo de execução!

        // Atribuição de tipo bruto para genérico
        strOb = raw; // Correto, mas perigoso
        // String str = strOb.getob(); // Erro de tempo de execução!

        // Atribuição de genérico para tipo bruto
        raw = iOb; // Correto, mas perigoso
        // d = (Double) raw.getob(); // Erro de tempo de execução!
    }
}

Recomendaciones Evite usar tipos brutos:

    Siempre use argumentos de tipo para disfrutar de la seguridad ofrecida por los genéricos.
Ejemplo:


gen iob = new Gen (88); // Correcto y seguro 
// Classe Gen com suporte a genéricos
class Gen {
    T ob; // Declara um objeto do tipo T

    Gen(T o) { // Construtor
        ob = o;
    }

    T getob() { // Retorna o objeto ob
        return ob;
    }
}

// Demonstração de tipos brutos
class RawDemo {
    public static void main(String[] args) {
        // Usando genéricos corretamente
        Gen iOb = new Gen(88);
        Gen strOb = new Gen("Generics Test");

        // Criando um tipo bruto
        Gen raw = new Gen(new Double(98.6));
        double d = (Double) raw.getob(); // Funciona, mas perde segurança de tipos
        System.out.println("value: "   d);

        // Erros de tempo de execução com tipos brutos
        // int i = (Integer) raw.getob(); // Erro de tempo de execução!

        // Atribuição de tipo bruto para genérico
        strOb = raw; // Correto, mas perigoso
        // String str = strOb.getob(); // Erro de tempo de execução!

        // Atribuição de genérico para tipo bruto
        raw = iOb; // Correto, mas perigoso
        // d = (Double) raw.getob(); // Erro de tempo de execução!
    }
}

trate el código heredado con cuidado:

    Agregue cheques y pruebas rigurosas integrando pregenerico con código genérico.
Declaración de liberación Este artículo se reproduce en: https://dev.to/javapariniciantes/tipos-brutos-e-codigo-legado-3c6m?1 Si hay alguna infracción, comuníquese con [email protected] para eliminarlo.
Último tutorial Más>
ClasificaciónMás>
Aprende japonés Aprender coreano Aprender chino Aprender idioma extranjero Juego Problema comun Periféricos tecnológicos AI Tutoriales de software Programación Artículo

Estudiar chino

HerramientaMás>
Decodificación de imagen base64
pinyin chino
Codificación Unicode
Compresión de cifrado de ofuscación JS
Herramienta de cifrado hexadecimal de URL
Herramienta de conversión de codificación UTF-8
Herramientas de codificación y decodificación Ascii en línea
herramienta de cifrado MD5
Herramienta de cifrado y descifrado de texto hash/hash en línea
Cifrado SHA en línea

Descargo de responsabilidad: Todos los recursos proporcionados provienen en parte de Internet. Si existe alguna infracción de sus derechos de autor u otros derechos e intereses, explique los motivos detallados y proporcione pruebas de los derechos de autor o derechos e intereses y luego envíelos al correo electrónico: [email protected]. Lo manejaremos por usted lo antes posible.

Copyright© 2022 湘ICP备2022001581号-3