Applicazione del mondo reale di conversione allargamento/restringimento?

Question

Qualcuno può spiegare perché si dovrebbe mai utilizzare la conversione di allargamento o restringimento? Ho letto molto su questi, ma nessuno mi dà mai un esempio pratico. Grazie!

Answer 1

(Java) Le conversioni di allargamento e restringimento hanno a che fare con la conversione tra tipi correlati. Prendiamo, ad esempio, la relazione tra una classe astratta (super) e la sua sottoclasse (secondaria); usiamo la classe java.lang.Number (abstract) e una sottoclasse diretta integer. Qui abbiamo:

(superclass)        Number 
            __________/\__________ 
           /  |  |  \ 
(concrete subclasses)   Integer Long Float Double 

Allargamento Conversione: verifica se prendiamo un tipo specifico (sottoclasse) e si tenta di assegnare a un tipo meno specifico (superclasse).

Integer i = new Integer(8); 
Number n = i; // this is widening conversion; no need to cast 

conversione Narrowing: si verifica quando prendiamo un tipo meno specifico (superclasse) e si tenta di assegnare a un tipo più specifico (sottoclasse), che richiede cast esplicito.

Number n = new Integer(5); // again, widening conversion 
Integer i = (Integer) n; // narrowing; here we explicitly cast down to the type we want - in this case an Integer 

ci sono alcune questioni che è necessario essere a conoscenza di quali ClassCastExceptions:

Integer i = new Integer(5); 
Double d = new Double(13.3); 
Number n; 

n = i; // widening conversion - OK 
n = d; // also widening conversion - OK 

i = (Integer) d; // cannot cast from Double to Integer - ERROR 

// remember, current n = d (a Double type value) 
i = (Integer) n; // narrowing conversion; appears OK, but will throw ClassCastException at runtime - ERROR 

Un modo per gestire questa situazione è quello di utilizzare un if dichiarazione con la parola chiave instanceof:

if(n instanceof Integer) { 
     i = (Integer) n; 
} 

Perché vuoi usare questo? Diciamo che stai facendo una gerarchia di personale per alcuni programmi e hai una superclasse generica chiamata "Persona" che prende un nome e un cognome come parametri e sottoclassi "Studente", "Insegnante", "Segretario", ecc. puoi inizialmente creare una persona generica e assegnarla (tramite ereditarietà), ad esempio, a uno studente che avrebbe un campo variabile aggiuntivo per studenID impostato nel suo costruttore. È possibile utilizzare un unico metodo che prende le più generiche (più ampi) di tipo come parametro e di gestire tutte le sottoclassi di quel tipo così:

public static void main(String[] args) { 
    Person p = new Student("John", "Smith", 12345); 
    printInfo(p); 
} 

// this method takes the wider Person type as a parameter, though we can send it a narrower type such as Student if we want 
public static void printInfo(Person p) { 
    System.out.println("First: " + p.getFirstName()); 
    System.out.println("Last: " + p.getLastName()); 
    if (p instanceof Student) { 
     System.out.println((Student)p).getStudentID()); // we cast p to Student with Narrow Conversion which allows us to call the getStudentID() method; only after ensuring the p is an instance of Student 
    } 
} 

Mi rendo conto che questo potrebbe non essere il modo ideale per gestire le cose, ma per Per motivi di dimostrazione, ho pensato che servisse per mostrare alcune delle possibilità.

Answer 2

Se un codice restituisce un valore int contenente un valore vero/falso, è possibile ridurlo manualmente a un valore bool che rappresenta ciò che rappresenta correttamente.
Puoi anche fare il contrario.

È possibile ampliare un char a int per fare alcuni confronti con i valori ascii.

È possibile prendere un'istanza di Dog e ampliarla a IAnimal per passarla a una funzione.

È possibile ridurre uno IAnimal a Dog quando si conosce il tipo di animale in uno List<IAnimal> in una fabbrica o altrove per qualsiasi motivo.

Answer 3

Le conversioni implicite vengono utilizzate per eseguire calcoli matematici con valori numerici di tipi diversi. Ad esempio, se now() restituisce un timestamp in secondi, come un lungo:

long t = now() 
long nextMinute = t + 60 

avete fatto una conversione implicita ampliamento di 60 (un int) per un lungo in modo da poter aggiungere al t. Essere in grado di fare queste conversioni rende la matematica molto più facile da codificare.

Answer 4

Un esempio canonico di conversione di allargamento e restringimento è il modo in cui funzionano determinate librerie di I/O di file. Spesso, una libreria di elaborazione file avrà una funzione/metodo che legge un singolo carattere da un file. Se c'è un carattere da leggere, la funzione dovrebbe restituire quel carattere e, se non ci sono caratteri, dovrebbe restituire un valore sentinella EOF per segnalarlo.

Perché qualsiasi carattere può apparire in un file, in genere la funzione/metodo sarebbe avere questa firma:

int readCharacter(); 

Qui, la funzione restituisce un int che contiene un valore char se un personaggio è stato letto e che detiene EOF come sentinella altrimenti. EOF viene in genere scelto come numero intero troppo grande da contenere in un char. In questo modo, puoi fare ciò:

while (true) { 
    int ch = readCharacter(); 
    if (ch == EOF) break; 

    char actualCharValue = (char) ch; 
    /* process actualCharValue here */ 
} 

Spero che questo aiuti!

Answer 5

prendere questa ...

conversione - Specialized -> generalizzata, allora è conosciuto come Widening, quando si sono sempre più generale.

Come Chirurgo -> Medico. In questo caso, non hai bisogno di un casting. Perché, un chirurgo è un Medico di default. Quindi, è naturale che un chirurgo possa eseguire tutte quelle cose che un Medico può fare.

Mentre d'altra parte, Conversione - Generalizzato -> Specializzato, quindi è noto come restringimento, quando si sta diventando più specializzato.

Come Medico -> Chirurgo. Bene, in questo caso, devi aggiungere casting. Perché un medico può essere un chirurgo o un medico o un'infermiera. Pensaci, se chiedi a un'infermiera di operare su di te ...

Orribile, giusto ???

Spero che tu abbia avuto l'idea.