Hi Mihai,
That was an insightful reply. If I understand you right, if
getLines() did not return a clone of the array held in the lines field,
then subsequent direct access to the returned array's elements would
effectively bypass the getLines(int) and/or setLines(int,String) accessors.
Thanks!
-Pete Soper
On 7/2/2010 3:32 AM, Mihai DINCA wrote:
> Hi Pete,
>
> I think the difference is there for philosophic purposes.
>
> If you have a bean Person with attributes firstName, lastName and
> address, and address is of the type Address, another bean, then the code
> that uses that bean is supposed to:
> -- not be allowed to directly change the address handle (such as
> person.address = new Address(...)), but forced to change it only by set/get
> -- change the address fields (such as street and so) in the way the
> Address bean allows (i.e. by set/get typically)
>
> Now, let's say the Person uses an array of Address. It is like having
> address0, address1, ... fields. You are not supposed to change directly
> them (such as address1 = new Address(...) or addresses[1] = new
> Address(...)) but only using the setter (setAddress1(new Address(...))
> or setAddresses(1, new Address()). If getAddresses() returned the array
> by itself, you could then modify directly the addresses, bypassing the
> setter, such as getAddresses()[1]=new Address(...); <-- it changes the
> value in the person bean itself. Returning a clone, let you do whatever
> you want to the clone, still being forced to pass through the setter
> setAddresses(1, new Address(...)) for changing the corresponding address.
>
> In other words, the difference comes from the fact that the array is not
> considered as an object member of the bean, but a shortcut for defining
> more than one similar members.
>
> Hope it helps
> Mihai
>
>
> Pete Soper a écrit :
>> In the 1029 JavaBeans module in exercise 2 source file
>> MyBeanIndedProperties.java is created and this class has the following
>> two getters that operate with the String[] instance field "lines":
>>
>> .
>> .
>> String[] lines = new String[10];
>> .
>> .
>> public String[] getLines() {
>> return this.lines.clone();
>> }
>>
>> public String getLines( int index ) {
>> return this.lines[index];
>> }
>>
>> Why would getLines return a ref to a clone of the array ref'd by
>> lines, while getLines returns a ref to the specific String in the
>> lines array?The clone operation only clones the array object: the
>> array elements are copies of the references, so both the orginal and
>> cloned arrays contain the same String object references.
>>
>> In other words, why wouldn't the code for getLines() be like this?
>>
>> public String[] getLines() {
>> return lines;
>> }
>>
>> Or, alternatively, why wouldn't getLines(int) be like this?
>>
>> public String[] getLines(int index) {
>> return this.lines[index].clone();
>> }
>>
>> Is this most likely a little inconsistency in the code, or is there
>> something about array semantics that I'm missing that makes this
>> difference useful?
>>
>> -Pete Soper
>>
>
--
To post to this group, send email to [email protected]
To unsubscribe from this group, send email to
[email protected]
For more options, visit this group at
http://groups.google.com/group/javaprogrammingwithpassion?hl=en
