Final Variables immutable class

[karimkhan pathan]

Hi,

Can i know if all the fields in the class are final ,then that class will become immutable ...Is the statement correct or not ..

please explain ..

regards,
Karim.

[Deepak Bala]

Not necessary. If your class holds final references to mutable objects, it is effectively a mutable class.

[John de Michele]

Karimkhan:

The final keyword only means that the reference can't be changed. It doesn't mean that the object the reference is referring to can't change internally. As Deepak said, you need to refer to immutable objects, or use some other technique like defensive copying.

John.

[Embla Tingeling]

karimkhan pathan wrote:Can i know if all the fields in the class are final ,then that class will become immutable ...Is the statement correct or not ..

It's correct if all variables are either primitives or references to immutable objects.

[Campbell Ritchie]

uj nossnahoj wrote: . . .It's correct if all variables are either primitives or references to immutable objects.

. . . and the class is tagged "final" too.

[S Majumder]

John de Michele wrote:Karimkhan:

The final keyword only means that the reference can't be changed. It doesn't mean that the object the reference is referring to can't change internally. As Deepak said, you need to refer to immutable objects, or use some other technique like defensive copying.

John.

Thanks all of you guys for sharing you'r knowledges ,

What is actually defensive copying ?

[Deepak Bala]

s begri wrote:

John de Michele wrote:Karimkhan:

The final keyword only means that the reference can't be changed. It doesn't mean that the object the reference is referring to can't change internally. As Deepak said, you need to refer to immutable objects, or use some other technique like defensive copying.

John.

Thanks all of you guys for sharing you'r knowledges ,

What is actually defensive copying ?

It is a method by which you return a copy of your member variable instead of a reference to it. Google it for more info.

You can also use techniques like Collections.unmodifiableList(). The javadoc should be able to help you understand the technique

[Campbell Ritchie]

public class Foo
{
    private int number;
    private String word;

    public Foo(int number, String word)
    {
        this.number = number;
        this.word = word;
    }

/*
 * Lots of other methods, too
 */
    public void setNumber(int number) . . .
    public void setWord(String word) . . .
    public String getWord() . . .
    public int getNumber() . . .
    @Override public String toString() . . .
    @Override public int hashCode() . . .
    @Override public boolean equals(Object obj) . . .

/*
 * So far we have an ordinary class with ordinary methods, which is mutable,
 * but a copy constructor has been added . . .
 */

/**
 * Copy constructor added because this is a mutable class and it is programmed
 * by somebody competent who knows you might need defensive copies :)
 *@param other A Foo object which will be copied
 */
    public Foo(Foo other)
    {
        this(other.getNumber(), other.getWord());
    }
}//end class Foo

public final class MyImmutableClass
{
    private final int number;
    private final String word;
    /*
     * The only mutable field
     */
    private final Foo fff;

    public MyImmutableClass(int number, String word, Foo f)
    {
        this.number = number;
        this.word = word;
        this.fff = f
     }//end constructor

/**
 *@return a primitive which has no link to the original object
 */
     public int getNumber()
     {
          return number;
     }

/**
 *@return a reference to the original object, but it is immutable
 */
     public String getWord()
     {
         return word;
     }

/**
 *@return a reference to a mutable object
 */
    public Foo getFFF()
    {
        return new Foo(fff);
    }
/*
 * Lots of other methods
 /*
}

The reference to the Foo object is not the same as the original object; you can play with the returned object to your heart's content without changing the state of the original Foo object. Note there are no methods which call the setNumber and setWord methods of the Foo reference. Copying the String in the Foo copy constructor does not require defensive copies because Strings are immutable.

[Embla Tingeling]

s begri wrote:What is actually defensive copying ?

It's a way of maintaining immutability of a class.

Instead of returning a reference to an internal and mutable data structure, you return a copy. The user can then modify it to his hearts desire without compromising the internals of the object.