Sauda��es JAVAnianas, que o sol SUN�nico esteja brilhando para todos...
Estou envinado em anexo um trexo do tutorial da SUN que faz um brief sobre acomo o JAVA trata a passagem de informa��es para os m�todos.
Bem, achei que tinha entendido mas agora compliquei de novo.
Se o argumento for um tipo primitivo a passagem � por valor e o m�todo n�o poder� alterar seu valor. Se n�o for do tipo primitivo, passar-se-a uma refer�ncia e o m�todo n�o poder� alterar a refer�ncia a este objeto. Ele d� pequenso trechos de exemplos mas confesso que a ficho (ou unidade n�o caiu). Como � que � tudo isso???
Algu�m poderia me explicar iso bem esplicadinho ou mesmo me indicar refer�ncias que procurarei l�-las atentamente.
+1vz muito obrigado...
Alessandro Moreira
Yahoo! GeoCities: a maneira mais f�cil de criar seu web site gr�tis!
Pass by Value In Java methods, arguments are passed by value. When invoked, the method receives the value of the variable passed in. When the argument is of primitive type, pass-by-value means that the method cannot change its value. When the argument is of reference type, pass-by-value means that the method cannot change the object reference, but can invoke the object's methods and modify the accessible variables within the object. This is often the source of confusion--a programmer writes a method that attempts to modify the value of one its arguments and the method doesn't work as expected. Let's look at such method and then investigate how to change it so that it does what the programmer originally intended.
Consider this series of Java statements which attempts to retrieve the current color
of a Pen object in a graphics application:
. . .
int r = -1, g = -1, b = -1;
pen.getRGBColor(r, g, b);
System.out.println("red = " + r +
", green = " + g +
", blue = " + b);
. . .
At the time when the getRGBColor method is called, the variables r, g, and b all have
the value -1. The caller is expecting the getRGBColor method to pass back the red,
green and blue values of the current color in the r, g, and b variables.
However, the Java runtime passes the variables' values (-1) into the getRGBColor
method; not a reference to the r, g, and b variables. So you could visualize the call
to getRGBColor like this: getRGBColor(-1, -1, -1).
When control passes into the getRGBColor method, the arguments come into scope (get
allocated) and are initialized to the value passed into the method:
class Pen {
int redValue, greenValue, blueValue;
void getRGBColor(int red, int green, int blue) {
// red, green, and blue have been created
// and their values are -1
. . .
}
}
So getRGBColor gets access to the values of r, g, and b in the caller through its
arguments red, green, and blue, respectively. The method gets its own copy of the
values to use within the scope of the method. Any changes made to those local copies
are not reflected in the original variables from the caller.
Now, let's look at the implementation of getRGBColor within the Pen class that the
method signature above implies:
class Pen {
int redValue, greenValue, blueValue;
. . .
// this method does not work as intended
void getRGBColor(int red, int green, int blue) {
red = redValue;
green = greenValue;
blue = blueValue;
}
}
This method will not work as intended. When control gets to the println statement in
the following code, which was shown previously, getRGBColor's arguments, red, green,
and blue, no longer exist. Therefore the assignments made to them within the method
had no effect; r, g, and b are all still equal to -1.
. . .
int r = -1, g = -1, b = -1;
pen.getRGBColor(r, g, b);
System.out.println("red = " + r +
", green = " + g +
", blue = " + b);
. . .
Passing variables by value affords the programmer some safety: Methods cannot
unintentionally modify a variable that is outside of its scope. However, you often
want a method to be able to modify one or more of its arguments. The getRGBColor
method is a case in point. The caller wants the method to return three values through
its arguments. However, the method cannot modify its arguments, and, furthermore, a
method can only return one value through its return value. So, how can a method return
more than one value, or have an effect (modify some value) outside of its scope?
For a method to modify an argument, it must be of a reference type such as an object
or array. Objects and arrays are also passed by value, but the value of an object is a
reference. So the effect is that arguments of reference types are passed in by
reference. Hence the name. A reference to an object is the address of the object in
memory. Now, the argument in the method is referring to the same memory location as
the caller.
Let's rewrite the getRGBColor method so that it actually does what you want. First,
you must introduce a new type of object, RGBColor, that can hold the red, green and
blue values of a color in RGB space:
class RGBColor {
public int red, green, blue;
}
Now, we can rewrite getRGBColor so that it accepts an RGBColor object as an argument.
The getRGBColor method returns the current color of the pen by setting the red, green
and blue member variables of its RGBColor argument:
class Pen {
int redValue, greenValue, blueValue;
void getRGBColor(RGBColor aColor) {
aColor.red = redValue;
aColor.green = greenValue;
aColor.blue = blueValue;
}
}
And finally, let's rewrite the calling sequence:
. . .
RGBColor penColor = new RGBColor();
pen.getRGBColor(penColor);
System.out.println("red = " + penColor.red +
", green = " + penColor.green +
", blue = " + penColor.blue);
. . .
The modifications made to the RGBColor object within the getRGBColor method affect the
object created in the calling sequence because the names penColor (in the calling
sequence) and aColor (in the getRGBColor method) refer to the same object.
------------------------------------------------------------------------------------------- Ceara' Java User Group Para cancelar sua assinatura, envie um e-mail para: [EMAIL PROTECTED] Para mais informacoes, mande um e-mail para: [EMAIL PROTECTED] Falar com o administrador? e-mail para: [EMAIL PROTECTED]
