Moderator: admin
Code: Select all
public class Main {
public static void main(String[] args) {
class A{
private int x=10;
void foo(A a){a.x++;}
int getX(){return x;}
}
A a1=new A();
A a2=new A();
a1.foo(a2);
}
}
. As a consequence the keyword 'final' isn't really needed...Can it be?Yes, the explanation notes this point, "Don't allow subclasses to override methods. The simplest way to do this is to declare the class as final. A more sophisticated approach is to make the constructor private and construct instances in factory methods."javabean68 wrote:Hi all,
when the Constructor is private the class is 'effectively' final
Thank you for your help,
Greetings
Fabio
Isn't this answer option in the quote an equally good answer? Thanks.Make constructor private.
Argh.... I see. Thank you.admin wrote:Making constructor private is not the only thing required. As per Oracle's documentation noted in the explanation, "A more sophisticated approach is to make the constructor private and construct instances in factory methods.".
The option doesn't mention the second part.
Hi,4. If the instance fields include references to mutable objects, don't allow those objects to be changed:
Don't provide methods that modify the mutable objects.
Don't share references to the mutable objects. Never store references to external, mutable objects passed to the constructor; if necessary, create copies, and store references to the copies. Similarly, create copies of your internal mutable objects when necessary to avoid returning the originals in your methods.
don't allow those objects to be changed?If the instance fields include references to mutable objects, don't allow those objects to be changed:
As far as this is concerned, we just need to make OUR class (*) not provide a method that delegates the responsibility of changing the value(s) of a mutable object via the setter method of the class, from which the mutable object is instantiated.Don't provide methods that modify the mutable objects.
With the quote immediately above, I sort of get what you are trying to do but then I suppose, I'm not fully getting what you are suggesting. I hope you could help me understand this. For the ideas you suggested in the quote immediately above, I've written the working code (The code in the following post due to 3000-char limit here) to implement the idea you suggested.Don't share references to the mutable objects. Never store references to external, mutable objects passed to the constructor; if necessary, create copies, and store references to the copies. Similarly, create copies of your internal mutable objects when necessary to avoid returning the originals in your methods.
Code: Select all
class MutableClass{
int mtbl_int;
MutableClass(int input){
mtbl_int = input;
}
void setter(int new_value){
mtbl_int = new_value;
}
}
public class ImmutableClassTest{
private final MutableClass ptr;
private ImmutableClassTest(MutableClass mtbl_obj){
ptr = new MutableClass(mtbl_obj.mtbl_int);
System.out.println("Mutable object from the ImmutableClassTest constructor: " + ptr);
}
public MutableClass getter(){
return new MutableClass(ptr.mtbl_int);
}
public static void main(String... args){
MutableClass var = new MutableClass(555);
System.out.println("\nMutableClass object from main: " + var + "\n");
ImmutableClassTest temp = new ImmutableClassTest(var);
System.out.println("\ntemp Before\n***********\n" + temp.ptr.mtbl_int + "\n");
ImmutableClassTest trying_to_change = temp;
trying_to_change.ptr.mtbl_int = 777;
System.out.println("temp After\n**********\n" + temp.ptr.mtbl_int + "\n");
System.out.println("trying_to_change\n****************\n" + trying_to_change.ptr.mtbl_int + "\n");
}
}I think you are making it more complicated that it really is. All you want is for the values inside an object to not change. What can you do to prevent anyone from changing the values inside that object? Choke off all ways through which such values can be changed, of course.schchen2000 wrote:I understand this is a lot to discuss but please help me understand the concepts. Many thanks.
Schmichael
If your class has contains reference to another mutable class then, if you follow both the above directions (not just one), you can make your class immutable.4. If the instance fields include references to mutable objects, don't allow those objects to be changed:
Don't provide methods that modify the mutable objects.
Don't share references to the mutable objects. Never store references to external, mutable objects passed to the constructor; if necessary, create copies, and store references to the copies. Similarly, create copies of your internal mutable objects when necessary to avoid returning the originals in your methods.
That's right. The object of class immutableClassTest has become mutable in the end. That's what I meant; however, the value inside the original mutable object (i.e. the one instantiated inside main in my provided code) did not get changed when the program finally stops. Does that mean I get my mission accomplished, i.e. not allowing to change a value inside a mutable object?Are you saying that since you are able to change the value using trying_to_change.ptr.mtbl_int = 777; your object of class ImmutableClassTest is not immutable?
That is not entirely correct. The concept of mutability applies to mutation by others. The point is that other classes should not be able to change the state of an object of the class that promises that it is immutable. If the class itself changes the value from inside then that is something else entirely.schchen2000 wrote:That's right. The object of class immutableClassTest has become mutable in the end. That's what I meant;Are you saying that since you are able to change the value using trying_to_change.ptr.mtbl_int = 777; your object of class ImmutableClassTest is not immutable?
Yes.however, the value inside the original mutable object (i.e. the one instantiated inside main in my provided code) did not get changed when the program finally stops. Does that mean I get my mission accomplished, i.e. not allowing to change a value inside a mutable object?
Thanks.
Schmichael
The option doesn't mention the second part. - Is it not obvious? otherwise we can not instantiate this object (if not take into account reflection and some other unobvious ways)Making constructor private is not the only thing required. As per Oracle's documentation noted in the explanation, "A more sophisticated approach is to make the constructor private and construct instances in factory methods.".
The option doesn't mention the second part.
Hi admin,admin wrote: ↑Sat Jun 18, 2016 10:56 amMaking constructor private is not the only thing required. As per Oracle's documentation noted in the explanation, "A more sophisticated approach is to make the constructor private and construct instances in factory methods.".
The option doesn't mention the second part.
Well yes this is true but none of the answers is the only thing required. Every answer identified as correct is not a solution in and of itself. It is one thing of many that needs to be done or can be done (which is what the question asks) in order to make a class immutable. So it is inconsistent of you to say that one answer is incorrect because it is not a complete solution in and of itself.Making constructor private is not the only thing required
Users browsing this forum: No registered users and 8 guests