"Si un ouvrier veut bien faire son travail, il doit d'abord affûter ses outils." - Confucius, "Les Entretiens de Confucius. Lu Linggong"
Outils en ligne
Tutoriel logiciel
Navigation sur les sites
La programmation
Page de garde > La programmation > Conseils pour traiter les types difficiles et le code hérité

Conseils pour traiter les types difficiles et le code hérité

Publié le 2025-04-17
Parcourir:417

Tipos brutos e código legado

Les types bruts ont été introduits pour compatibilité entre les codes hérités (pré-génériques) et les génériques introduits dans JDK 5. Ils activent la transition progressive, mais compromettent .

Définitions et caractéristiques Type brut:

    Utilisez une classe générique sans spécifier les arguments de type. Exemple:
gen brut = new Gen (nouveau double (98.6)); // type brut créé 
Gen raw = new Gen(new Double(98.6)); // Tipo bruto criado

Compatibilité:

Les variables de type brut peuvent recevoir n'importe quel objet générique et vice versa.

Il n'y a pas de vérification des types en temps de compilation, ce qui entraîne des erreurs possibles dans le temps d'exécution.

Exemple de code

// classe Gen avec support générique classe Gen { T ob; // déclare un objet de type T Gen (t o) {// constructeur Ob = o; } T getOB () {// Renvoie l'objet OBS Retour OB; } } // démonstration de types bruts Classe RawDemo { Public static void main (String [] args) { // en utilisant correctement les génériques Gen iOB = new Gen (88); Gen strob = new Gen ("test générique"); // Création d'un type brut Gen brut = new Gen (nouveau double (98,6)); double d = (double) brut.getOB (); // fonctionne, mais perd la sécurité de type System.out.println ("Valeur:" D); // erreurs de temps d'exécution avec des types bruts // int i = (entier) brut.getOB (); // Erreur de temps d'exécution! // Affectation de type brut pour générique Strob = brut; // correct, mais dangereux // string str = strob.getOB (); // Erreur de temps d'exécution! // Attribution brute générique Brut = ioB; // correct, mais dangereux // d = (double) brut.getOB (); // Erreur de temps d'exécution! } } 
// 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!
    }
}

risques de l'utilisation de types brut
Manque de type Sécurité:

    attribuer des types bruts aux génériques ou vice versa peut entraîner des erreurs en temps d'exécution.
Exemples:


strob = brut; // dangereux: Raw contient le double, mais Strob attend la ficelle Brut = ioB; // dangereux: brut contient maintenant entier, mais la coercition peut échouer 
// 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!
    }
}

Exceptions en temps d'exécution:

Il n'y a aucun moyen de détecter les incohérences en temps de compilation.

Exemple:

int i = (entier) brut.getOB (); // Erreur pourquoi RAW contient le double 
// 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!
    }
}

Notes non -verrification:

    Le compilateur Javac génère des avertissements lorsqu'il détecte les types bruts utilisés de manière insérect.
Exemples qui génèrent des avertissements


gen brut = new Gen (nouveau double (98.6)); // type brut Strob = brut; // Affectation sans sécurité 
// 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!
    }
}

recommandations Évitez d'utiliser des types bruts:

    Utilisez toujours des arguments de type pour profiter de la sécurité offerte par les génériques.
Exemple:


gen iOB = new Gen (88); // correct et sûr 
// 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!
    }
}

Traitez soigneusement le code hérité:

    Ajoutez des vérifications et des tests rigoureux en intégrant pré-générique avec le code générique.
Déclaration de sortie Cet article est reproduit à: https://dev.to/javaparainciciantes/tipos-brutos-ecodigo-legado-3c6m?1 s'il y a une contrefaçon, veuillez contacter [email protected] pour le supprimer.
Dernier tutoriel Plus>
ClassificationPlus>
Apprendre le japonais Apprendre le coréen Apprendre le chinois Apprendre une langue étrangère Jeu Problème commun Périphériques technologiques IA Tutoriel logiciel La programmation Article

Étudier le chinois

OutilPlus>
Décodage d'images en base64
Pinyin chinois
Encodage Unicode
Compression de chiffrement d'obscurcissement JS
Outil de chiffrement hexadécimal d'URL
Outil de conversion d'encodage UTF-8
Outils d'encodage et de décodage Ascii en ligne
Outil de cryptage MD5
Outil de cryptage et de décryptage en ligne de texte de hachage/hachage
Cryptage SHA en ligne

Clause de non-responsabilité: Toutes les ressources fournies proviennent en partie d'Internet. En cas de violation de vos droits d'auteur ou d'autres droits et intérêts, veuillez expliquer les raisons détaillées et fournir une preuve du droit d'auteur ou des droits et intérêts, puis l'envoyer à l'adresse e-mail : [email protected]. Nous nous en occuperons pour vous dans les plus brefs délais.

Copyright© 2022 湘ICP备2022001581号-3