Rif e out di C# in Java

Question

Come sappiamo, entrambe le lingue sono pass-by-value quando si passano i parametri ai metodi. Ma C# supporta le parole chiave ref e out per il pass-by-reference dei tipi primitivi. Sto cercando le stesse parole chiave e la stessa tecnica in Java?

La mia ipotesi sta usando Integer classe wrapper invece di int in Java per passare.

Eventuali suggerimenti ed esempi?

Answer 1

tua ipotesi è corretta. È necessario un wrapper (ma non intero poiché è immutabile).

Alcune persone usano array di elementi singoli per questo scopo:

int[] x = { 0 }; 
int[] y = { 0 }; 
someMethod(x, y); 
return x[0] + y[0]; 

Molti saranno rango che la tecnica proprio lì con GOTO.

Alcune persone definiscono una classe di supporto generico:

public class Holder<T> { 
    private T _value; 
    private Holder(T value) { _value = value; } 
    public static of(T value) { return new Holder<T>(value); } 
    public T getValue() { return _value; } 
    public void setValue(T value) { _value = value; } 
} 

... 

Holder<String> x = Holder.of("123"); 
Holder<String> y = Holder.of("456"); 
someMethod(x, y); 
return x.getValue() + y.getValue(); 

Alcuni definiscono un tipo appositamente costruito:

SomeMethodResult result = someMethod(x, y); 
return result.getX() + result.getY(); 

Alcuni potrebbero organizzare il lavoro da fare all'interno del metodo, evitando la necessità per argomenti di riferimento in primo luogo:

return someMethod(x, y); 

Ognuna di queste tecniche s ha vantaggi e svantaggi:

• matrici: semplice vs.brutto, si basa su array di avere esattamente un elemento
• titolare: sicuro contro verbose, boxe
• appositamente costruito Tipo: sicuro contro verbose, possibile eccessivo
• metodo di modifica: sicuro, pulito vs non sempre è possibile

Personalmente, penso che Java abbia incasinato questo. Preferisco evitare gli argomenti di riferimento, ma vorrei che Java permettesse più valori di ritorno da un metodo. Ma, sinceramente, non inciampo su questo molto spesso. Non darei un rene per questa funzione. :)

Answer 2

Java non supporta questa funzione.

Answer 3

Java non supporta il passaggio di tipi primitivi per riferimento.

Avvolgere un int come Integer non è d'aiuto, poiché è un tipo immutabile (vale a dire non può essere modificato una volta creato).

Answer 4

Java non ha questo built-in. Integer non lo farà, perché è immutabile. Non puoi cambiare il suo stato.

Dovrai creare la tua classe wrapper mutabile. Ma questo è molto "pericoloso" e può portare a risultati inaspettati, quindi cerca di evitarlo.

Answer 5

Java non hanno questa caratteristica

ecco un link per Java vs confronto C#

http://www.harding.edu/fmccown/java_csharp_comparison.html

ecco perché chiamano Java un linguaggio OOP non pura

Answer 6

L'unico modo per passare valore indietro è passare un riferimento a un valore mutabile come

public void calc(int[] value) { value[0] = 1; } 
public void calc(AtomicInteger value) { value.set(1); } 

tuttavia la cosa più semplice da fare è quello di restituire tutti i valori modificati

public int calc() { return 1; }