Im a beginner in java and i wanted to know in a simple way why you should use a parameterized constructor instead of a default one provided by the compiler.
Thanks
You'd need to use parameterized objects anytime you want to pass any sort of configuration into your object. You could use setters to pass in that information later, but not only is it shorter and cleaner to pass that information in at construction time, it lines up with the good practice of creating immutable objects, which cannot be modified after construction and have no setters. For example,
class Student {
private final String name;
private final Date birthday;
public Student(String name, Date birthday) {
this.name = name;
this.birthday = birthday;
}
}
In Java, a constructor is a method which is called by Java runtime during the object creation using the new operator. A reason for creating a constructor could be:
To initialize your object with default or initial state since default values may not be what you are looking for. For example, if you have a person class, containing a name and date of birth, you want these fields to be filled, not empty. So you would pass the values of the name and date of birth into the constructor of that class to assign the object with a value to use in that class.
By the default constructor any attributes your object might have are set to 0, false et cetera. If you want to set the attributes right away you can use a parameterized constructor. Also using you own constructor of course gives you the option of executing code before the object (technically while) is created.
By the way: The answer that "the default won't set any value to the properties" is wrong. For example this code:
public class Test {
private int test;
private boolean test2;
public static void main(String[] args) {
Test test = new Test();
System.out.println(test.test);
System.out.println(test.test2);
}
}
Will print out "0" and "false".
As in any object oriented language, a constructor method is used to allocate and initialize the memory for an object. With this in mind, a parameterized constructor method is used for setting properties of the object to certain value, while the default won't set any value to any of the properties.
In addition to what Louis Wasserman said, there are many situations where paramaterizing constructors makes sense from a logical point of view. Say you want to make an Employee object. There are certain attributes an employee MUST have to even be considered an employee, like a name, social security number, company and ofcourse a salary (slavery is illegal). Therefore, it would be logical to make a parameterized constructor requiring the 4 aforementioned variables.
Constructor helps class to initialize and set values to there some properties that are passed to it.That may be for current object of class.
For Ex.
class Education{
String typeOfEducation; //values are not set
String courseName;
Education(String type,String name){
typeOfEducation=type;
courseName=name; //values are set
}
}
Hope this helps.
I'm surprised no one has brought up overloading in this thread. Parameterized constructors also give the user the ability to set up an object to varying degrees based on information you have at creation time. You can do this with method overloading.
For example:
public Car(long vin){
this.vin = vin;
}
would set up a car object with only a vin number whereas this:
public Car(long vin, String make){
this.vin = vin;
this.make = make;
}
would create a similar Car object with additional information. In addition to overloading, you ought to look into copy constructors as well to get an idea of 'shallow' vs. 'deep' object copies. The following link has a decent example: http://www.geeksforgeeks.org/copy-constructor-in-java/
Related
i am a begginer with Java but i want to ask if i can append a method inside a list and how can i make a list? here is my code
public class My_Zoo {
private String Animal_name;
private String Cohabitation;
private String Gender;
private int Weight;
private int Maximum_age;
private String Animal_code;
public void Get_Animal(String A_name, String C, String G , int W , int M_a, String A_c ){
Animal_name = A_name;
Cohabitation = C;
Gender = G;
Weight = W;
Maximum_age = M_a;
Animal_code = A_c;
}
public void Tiger(){
Animal_name = "Tiger";
Cohabitation = "mammal";
Gender = "Female";
Weight = 170;
Maximum_age = 15;
Animal_code = "A01";
}
}
As you are starting with Java I think there are some things that we might say.
Java Conventions
In Java the name of everything has a convention, you can find it here:code conventions
Let me say some that might help you:
Class names: you do not use undescore, you will allways use CamelCase with first letter in capital, for exemple insteade of My_Zoo you should use MyZoo
Variable and parameters name: same as above, but withou first letter in capital, instead of Animal_name you should use animalName
Constructors
I noticed that you tried to make 2 constructors, Get_Animal and Tiger. In java all constructors have the same name of the class. If you do not put any constructors inside a class Java will use the default constructor that looks like this.
public MyZoo(){}
The only difference allowed between constructors is it´s parameters, so you cannot create it with different names, but you can make static methods that create objects for you:
public static MyZoo Tiger(){
MyZoo tiger = new MyZoo();//create the object
//use this to set the fields you you want
return tiger; //return the desired object
}
You can make the methods getAnimal and Tiger to be this way.
More information about static methods: static methods
Lists
In Java we have a class called Collections, on java.util package. All forms of collections extends from it, including the List class.
Those classes has methods to abstracts arrays and matrices processes. More about it: Collections
As it means only to hold a set of values your question doesn´t make sense, it seems that you are asking how to put a method inside a class. To me it appears you are mistaking list with class concept.
Although with java 8 or +, you can use the functional interface an make use of the function as a high order cientizen concept and add methods to a list, that must be a list of methods from the begning, as you are starting in Java and it is a advanced concept I don´t think it is your doubt.
Methods
At least let´s go to your question, but you already made it. Methods in java has 3 basic components: access modifier, return type and a name. You made 2: Get_Animal and Tiger. In Java syntax they are methods, not constructors as I said earlier. If you want put more methods just follow these rules, it´s pretty simple: Java Methods
I hope that things got more clear for you.
And you should learn more about Object Oriented concepts as weel, for example encapisulation, so you can access your fields from outside this class, you noted them with private modifier, so outside your class no one can see them.
Java allows to summarize this.classVar = parameter; this.classVar2 = parameter2; expressions to this(parameter, parameter2). At least used in a constructor.
But this code doesn't work when I change from the former way (commented in the code) to the latter way in a setter:
class Client {
String nombre, apellidos, residencia;
double comision;
void setClient(String nombre, String apellidos, String residencia, double comision){
this(nombre, apellidos, residencia, comision);
//this.nombre = nombre;
//this.apellidos = apellidos;
//this.residencia = residencia;
//this.comision = comision;
}
}
Error says:
"call to this must be first statement in the constructor.
Constructor in class Client cannot be applied to given types.
required: no arguments
<p>found: String, String, String, double
<p>reason: actual and formal argument list differ in length" (I haven't created one, just left the default).
So, is this way of using 'this' only valid for constructors, and therefore not suitable for setters? Does it require to explicitly code the constructor (if so, why?)?
Java allows to summarize this.classVar = parameter; this.classVar2 = parameter2; expressions to this(parameter, parameter2).
No, it doesn't. You still have to code the this.classVar = parameter; this.classVar2 = parameter2; somewhere. All this(parameter, parameter2) does is call a constructor (which would have to have the this.classVar = parameter; this.classVar2 = parameter2; code in it, if those parameters were going to be written to those fields).
You can't call the constructor from a setter. You can only call a constructor from within a constructor. It's used to consolidate logic in a single constructor even when you have more than one with varying parameters, for example:
public MyContainer(int size) {
this.size = size;
}
public MyContainer() {
this(16);
}
There, the zero-parameters version of the MyContainer constructor calls the single-parameter version, passing it 16 for the size parameter.
this(nombre, apellidos, residencia, comision) doesn't "summarize" anything.
It's just a way to call another constructor in the class from a constructor.
There is no way to "summarize" anything
this(/* zero or more args */);
This is a constructor call. You can use it from one constructor to refer to another (for lack of a better name, 'constructor chaining').
You cannot do the same thing from a normal method. If you want to create an object from within a normal method, you use the same syntax as you'd use an an external user of the class:
new MyClass(/* args */);
From your code, it doesn't look like this is the approach you'd want to take.
How to create immutable objects in Java?
Which objects should be called immutable?
If I have class with all static members is it immutable?
Below are the hard requirements of an immutable object.
Make the class final
make all members final, set them
explicitly, in a static block, or in the constructor
Make all members private
No Methods that modify state
Be extremely careful to limit access to mutable members(remember the field may be final but the object can still be mutable. ie private final Date imStillMutable). You should make defensive copies in these cases.
The reasoning behind making the class final is very subtle and often overlooked. If its not final people can freely extend your class, override public or protected behavior, add mutable properties, then supply their subclass as a substitute. By declaring the class final you can ensure this won't happen.
To see the problem in action consider the example below:
public class MyApp{
/**
* #param args
*/
public static void main(String[] args){
System.out.println("Hello World!");
OhNoMutable mutable = new OhNoMutable(1, 2);
ImSoImmutable immutable = mutable;
/*
* Ahhhh Prints out 3 just like I always wanted
* and I can rely on this super immutable class
* never changing. So its thread safe and perfect
*/
System.out.println(immutable.add());
/* Some sneak programmer changes a mutable field on the subclass */
mutable.field3=4;
/*
* Ahhh let me just print my immutable
* reference again because I can trust it
* so much.
*
*/
System.out.println(immutable.add());
/* Why is this buggy piece of crap printing 7 and not 3
It couldn't have changed its IMMUTABLE!!!!
*/
}
}
/* This class adheres to all the principles of
* good immutable classes. All the members are private final
* the add() method doesn't modify any state. This class is
* just a thing of beauty. Its only missing one thing
* I didn't declare the class final. Let the chaos ensue
*/
public class ImSoImmutable{
private final int field1;
private final int field2;
public ImSoImmutable(int field1, int field2){
this.field1 = field1;
this.field2 = field2;
}
public int add(){
return field1+field2;
}
}
/*
This class is the problem. The problem is the
overridden method add(). Because it uses a mutable
member it means that I can't guarantee that all instances
of ImSoImmutable are actually immutable.
*/
public class OhNoMutable extends ImSoImmutable{
public int field3 = 0;
public OhNoMutable(int field1, int field2){
super(field1, field2);
}
public int add(){
return super.add()+field3;
}
}
In practice it is very common to encounter the above problem in Dependency Injection environments. You are not explicitly instantiating things and the super class reference you are given may actually be a subclass.
The take away is that to make hard guarantees about immutability you have to mark the class as final. This is covered in depth in Joshua Bloch's Effective Java and referenced explicitly in the specification for the Java memory model.
Just don't add public mutator (setter) methods to the class.
Classes are not immutable, objects are.
Immutable means: my public visible state cannot change after initialization.
Fields do not have to be declared final, though it can help tremendously to ensure thread safety
If you class has only static members, then objects of this class are immutable, because you cannot change the state of that object ( you probably cannot create it either :) )
To make a class immutable in Java , you can keep note of the following points :
1. Do not provide setter methods to modify values of any of the instance variables of the class.
2. Declare the class as 'final' . This would prevent any other class from extending it and hence from overriding any method from it which could modify instance variable values.
3. Declare the instance variables as private and final.
4. You can also declare the constructor of the class as private and add a factory method to create an instance of the class when required.
These points should help!!
From oracle site, how to create immutable objects in Java.
Don't provide "setter" methods — methods that modify fields or objects referred to by fields.
Make all fields final and private.
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.
If the instance fields include references to mutable objects, don't allow those objects to be changed:
I. Don't provide methods that modify the mutable objects.
II. 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.
An immutable object is an object that will not change its internal state after creation. They are very useful in multithreaded applications because they can be shared between threads without synchronization.
To create an immutable object you need to follow some simple rules:
1. Don't add any setter method
If you are building an immutable object its internal state will never change. Task of a setter method is to change the internal value of a field, so you can't add it.
2. Declare all fields final and private
A private field is not visible from outside the class so no manual changes can't be applied to it.
Declaring a field final will guarantee that if it references a primitive value the value will never change if it references an object the reference can't be changed. This is not enough to ensure that an object with only private final fields is not mutable.
3. If a field is a mutable object create defensive copies of it for
getter methods
We have seen before that defining a field final and private is not enough because it is possible to change its internal state. To solve this problem we need to create a defensive copy of that field and return that field every time it is requested.
4. If a mutable object passed to the constructor must be assigned to a
field create a defensive copy of it
The same problem happens if you hold a reference passed to the constructor because it is possible to change it. So holding a reference to an object passed to the constructor can create mutable objects. To solve this problem it is necessary to create a defensive copy of the parameter if they are mutable objects.
Note that if a field is a reference to an immutable object is not necessary to create defensive copies of it in the constructor and in the getter methods it is enough to define the field as final and private.
5. Don't allow subclasses to override methods
If a subclass override a method it can return the original value of a mutable field instead of a defensive copy of it.
To solve this problem it is possible to do one of the following:
Declare the immutable class as final so it can't be extended
Declare all methods of the immutable class final so they can't be overriden
Create a private constructor and a factory to create instances of the immutable class because a class with private constructors can't be extended
If you follow those simple rules you can freely share your immutable objects between threads because they are thread safe!
Below are few notable points:
Immutable objects do indeed make life simpler in many cases. They are especially applicable for value types, where objects don't have an identity so they can be easily replaced and they can make concurrent programming way safer and cleaner (most of the notoriously hard to find concurrency bugs are ultimately caused by mutable state shared between threads).
However, for large and/or complex objects, creating a new copy of the object for every single change can be very costly and/or tedious. And for objects with a distinct identity, changing an existing objects is much more simple and intuitive than creating a new, modified copy of it.
There are some things you simply can't do with immutable objects, like have bidirectional relationships. Once you set an association value on one object, it's identity changes. So, you set the new value on the other object and it changes as well. The problem is the first object's reference is no longer valid, because a new instance has been created to represent the object with the reference. Continuing this would just result in infinite regressions.
To implement a binary search tree, you have to return a new tree every time: Your new tree will have had to make a copy of each node that has been modified (the un-modified branches are shared). For your insert function this isn't too bad, but for me, things got fairly inefficient quickly when I started to work on delete and re-balance.
Hibernate and JPA essentially dictate that your system uses mutable objects, because the whole premise of them is that they detect and save changes to your data objects.
Depending on the language a compiler can make a bunch of optimizations when dealing with immutable data because it knows the data will never change. All sorts of stuff is skipped over, which gives you tremendous performance benefits.
If you look at other known JVM languages (Scala, Clojure), mutable objects are seen rarely in the code and that's why people start using them in scenarios where single threading is not enough.
There's no right or wrong, it just depends what you prefer. It just depends on your preference, and on what you want to achieve (and being able to easily use both approaches without alienating die-hard fans of one side or another is a holy grail some languages are seeking after).
Don't provide "setter" methods — methods that modify fields or
objects referred to by fields.
Make all fields final and private.
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.
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.
First of all, you know why you need to create immutable object, and what are the advantages of immutable object.
Advantages of an Immutable object
Concurrency and multithreading
It automatically Thread-safe so synchronization issue....etc
Don't need to copy constructor
Don't need to implementation of clone.
Class cannot be override
Make the field as a private and final
Force callers to construct an object completely in a single step, instead of using a no-Argument constructor
Immutable objects are simply objects whose state means object's data can't change after the
immutable object are constructed.
please see the below code.
public final class ImmutableReminder{
private final Date remindingDate;
public ImmutableReminder (Date remindingDate) {
if(remindingDate.getTime() < System.currentTimeMillis()){
throw new IllegalArgumentException("Can not set reminder" +
" for past time: " + remindingDate);
}
this.remindingDate = new Date(remindingDate.getTime());
}
public Date getRemindingDate() {
return (Date) remindingDate.clone();
}
}
Minimize mutability
An immutable class is simply a class whose instances cannot be modified. All of the information contained in each instance is provided when it is created and is fixed for the lifetime of the object.
JDK immutable classes: String, the boxed primitive classes(wrapper classes), BigInteger and BigDecimal etc.
How to make a class immutable?
Don’t provide any methods that modify the object’s state (known as mutators).
Ensure that the class can’t be extended.
Make all fields final.
Make all fields private.
This prevents clients from obtaining access to mutable objects referred to by fields and modifying these objects directly.
Make defensive copies.
Ensure exclusive access to any mutable components.
public List getList() {
return Collections.unmodifiableList(list); <=== defensive copy of the mutable
field before returning it to caller
}
If your class has any fields that refer to mutable objects, ensure that clients of the class cannot obtain references to these objects. Never initialize such a field to a client-provided object reference or return the object reference from an accessor.
import java.util.Date;
public final class ImmutableClass {
public ImmutableClass(int id, String name, Date doj) {
this.id = id;
this.name = name;
this.doj = doj;
}
private final int id;
private final String name;
private final Date doj;
public int getId() {
return id;
}
public String getName() {
return name;
}
/**
* Date class is mutable so we need a little care here.
* We should not return the reference of original instance variable.
* Instead a new Date object, with content copied to it, should be returned.
* */
public Date getDoj() {
return new Date(doj.getTime()); // For mutable fields
}
}
import java.util.Date;
public class TestImmutable {
public static void main(String[] args) {
String name = "raj";
int id = 1;
Date doj = new Date();
ImmutableClass class1 = new ImmutableClass(id, name, doj);
ImmutableClass class2 = new ImmutableClass(id, name, doj);
// every time will get a new reference for same object. Modification in reference will not affect the immutability because it is temporary reference.
Date date = class1.getDoj();
date.setTime(date.getTime()+122435);
System.out.println(class1.getDoj()==class2.getDoj());
}
}
For more information, see my blog:
http://javaexplorer03.blogspot.in/2015/07/minimize-mutability.html
an object is called immutable if its state can not be changed once created. One of the most simple way of creating immutable class in Java is by setting all of it’s fields are final.If you need to write immutable class which includes mutable classes like "java.util.Date". In order to preserve immutability in such cases, its advised to return copy of original object,
Immutable Objects are those objects whose state can not be changed once they are created, for example the String class is an immutable class. Immutable objects can not be modified so they are also thread safe in concurrent execution.
Features of immutable classes:
simple to construct
automatically thread safe
good candidate for Map keys and Set as their internal state would not change while processing
don't need implementation of clone as they always represent same state
Keys to write immutable class:
make sure class can not be overridden
make all member variable private & final
do not give their setter methods
object reference should not be leaked during construction phase
The following few steps must be considered, when you want any class as an immutable class.
Class should be marked as final
All fields must be private and final
Replace setters with constructor(for assigning a value to a
variable).
Lets have a glance what we have typed above:
//ImmutableClass
package younus.attari;
public final class ImmutableExample {
private final String name;
private final String address;
public ImmutableExample(String name,String address){
this.name=name;
this.address=address;
}
public String getName() {
return name;
}
public String getAddress() {
return address;
}
}
//MainClass from where an ImmutableClass will be called
package younus.attari;
public class MainClass {
public static void main(String[] args) {
ImmutableExample example=new ImmutableExample("Muhammed", "Hyderabad");
System.out.println(example.getName());
}
}
Commonly ignored but important properties on immutable objects
Adding over to the answer provided by #nsfyn55, the following aspects also need to be considered for object immutability, which are of prime importance
Consider the following classes:
public final class ImmutableClass {
private final MutableClass mc;
public ImmutableClass(MutableClass mc) {
this.mc = mc;
}
public MutableClass getMutClass() {
return this.mc;
}
}
public class MutableClass {
private String name;
public String getName() {
return this.name;
}
public void setName(String name) {
this.name = name;
}
}
public class MutabilityCheck {
public static void main(String[] args) {
MutableClass mc = new MutableClass();
mc.setName("Foo");
ImmutableClass iMC = new ImmutableClass(mc);
System.out.println(iMC.getMutClass().getName());
mc.setName("Bar");
System.out.println(iMC.getMutClass().getName());
}
}
Following will be the output from MutabilityCheck :
Foo
Bar
It is important to note that,
Constructing mutable objects on an immutable object ( through the constructor ), either by 'copying' or 'cloing' to instance variables of the immutable described by the following changes:
public final class ImmutableClass {
private final MutableClass mc;
public ImmutableClass(MutableClass mc) {
this.mc = new MutableClass(mc);
}
public MutableClass getMutClass() {
return this.mc;
}
}
public class MutableClass {
private String name;
public MutableClass() {
}
//copy constructor
public MutableClass(MutableClass mc) {
this.name = mc.getName();
}
public String getName() {
return this.name;
}
public void setName(String name) {
this.name = name;
}
}
still does not ensure complete immutability since the following is still valid from the class MutabilityCheck:
iMC.getMutClass().setName("Blaa");
However, running MutabilityCheck with the changes made in 1. will result in the output being:
Foo
Foo
In order to achieve complete immutability on an object, all its dependent objects must also be immutable
From JDK 14+ which has JEP 359, we can use "records". It is the simplest and hustle free way of creating Immutable class.
A record class is a shallowly immutable, transparent carrier for a fixed set of fields known as the record components that provides a state description for the record. Each component gives rise to a final field that holds the provided value and an accessor method to retrieve the value. The field name and the accessor name match the name of the component.
Let consider the example of creating an immutable rectangle
record Rectangle(double length, double width) {}
No need to declare any constructor, no need to implement equals & hashCode methods. Just any Records need a name and a state description.
var rectangle = new Rectangle(7.1, 8.9);
System.out.print(rectangle.length()); // prints 7.1
If you want to validate the value during object creation, we have to explicitly declare the constructor.
public Rectangle {
if (length <= 0.0) {
throw new IllegalArgumentException();
}
}
The record's body may declare static methods, static fields, static initializers, constructors, instance methods, and nested types.
Instance Methods
record Rectangle(double length, double width) {
public double area() {
return this.length * this.width;
}
}
static fields, methods
Since state should be part of the components we cannot add instance fields to records. But, we can add static fields and methods:
record Rectangle(double length, double width) {
static double aStaticField;
static void aStaticMethod() {
System.out.println("Hello Static");
}
}
First please understand that I may have this totally wrong which is why google isn't help.
I am trying to construct the following object: M3Tools
public class M3UTrack {
private String path;
private int secondsDuration;
private String label;
//Get and set of these omitted
public M3UTrack()
{
path = null;
label = null;
secondsDuration = 0;
}
public M3UTrack(M3UTrack t)
{
// Creating a track as a duplicate of the track you pass it?
path = new String(t.getPath());
label = new String(t.getLabel());
secondsDuration = t.getSecondsDuration();
}
From what I gather if I was to use the second constructor I would have to pass an object of itself??? It's throwing me in a loop. There are other classes involved.
The M3UTrack(M3UTrack t) is a so called copy constructor, because it creates a new instance but copies the values of the other. If you want to create a first/new instance you would probably use the first version. The class and constructor are public, so nothing should stop you from writing
M3UTrack t = new M3UTrack(); // default constructor
t.setPath(...); t.setLabel(...); t.setDurationSeconds(10); // fill data
M3UTrack s = new M3UTrack(t); // sample usage of copy constructor
If you have problems with this you need to show us your code and your error message. It is a compile time or runtime error? If it is a stacktrace please also tell us which line numbers are involved.
BTW: you might want to add another constructor which alles to specify all mandatory fields, so you dont need to use the setters. This has the advantage that you never have a "half" constructed object. When you omit the setters then you are using a pattern called immutable object:
public M3UTrack(String path, String label, int duration)
{
this.path = path;
this.label = label;
this.secondsDuration = duration;
}
And then construct it like:
M3UTrack t = new M3UTrack("file.mp3", "Songs", 10/*sec*/);
You can perfectly reference an object of a class you are defining. If not, how could you create copy constructors? which, by the way, is exactly what you are doing at public M3UTrack(M3UTrack t).
From Wikipedia:
Copy constructors define the actions performed by the compiler when
copying class objects. A copy constructor has one formal parameter
that is the type of the class (the parameter may be a reference to an
object)...
From what it looks like, you'd construct an instance of M3Track and set the properties on it. If you want to make a copy, you have the given copy constructor as an option.
This construct has name "copy constructor"and is used in specyfic places. Normal use first, no arguments construcror.
Usage of copy constructor, like name says, is "between" two objects (old and new), seems Your use case never occur (sorry for spelling, this from phone)
M3UTrack theNew = new M3UTrack(theOld)
class Employee {
public String name = "John";
public void modifyName(String name)
{
name = name; // I know using 'this' would be helpful, but I dont want to
}
System.out.println(name);
}
class Someclass {
public static void main(String[] args)
{
Employee e1 = new Employee();
System.out.println(e1.modifyName("Dave"));
System.out.println(e1.name); // Does this outputs John or Dave?
}
}
Does the method modifyName behave like a setter and change the instance variable name to be "Dave"?
Do methods only behave like a setter when they follow the naming convention setProperty?
modifyName is not working, will it work if it is named setName?
To directly answer your question, no the naming convention of the method does not cause it to act as a setter.
If that were the case, there would be no need for a method body.
public void setName(String name) {
}
would behave the same as
public void setName(String name) {
this.name = "I don't care what name you gave";
}
Which is not the case at all.
The reason your particular method is not working, is because of the statement:
// I know using 'this' would be helpful, but I dont want to
The reason that you use this.name is to distinguish between the method parameter and the instance member. The instance member is shadowed by the parameter, so without this.name you are simply overwriting the method parameter with itself.
If you absolutely refuse to use this.name for whatever (silly) reason then you should change the name of the parameter:
public void modifyName(String iHateUsingThis) {
name = iHateUsingThis;
}
Within a method, a method parameter takes precedence over an instance variable. The method modifyName refers to method parameter name, not the instance variable name.
If you don't use this for instance variable. Then you are just playing with the method variable in the following statement:
name = name; // I know using 'this' would be helpful, but I dont want to
asa result, nothing will be changed
In modifyName, the name parameter would hide the isntance member, and therefore the instance member won't be set (e1.modifyName("Dave") would change nothing). You should either write this.name = name; or use a different name for the instance member.
Does the method modifyName cannot be a setter only because of the naming convetion? modifyName() treats name as method parameter just because of not using JavaBean naming conventions?
The behavior has nothing to do with the naming convention of the method. It would behave the same if you change it to setName. The only thing that would make a difference is changing the parameter name or instance member name, to make them different.
Within a method block local variable will be used (if the name is same as that of the global variable). Hence there will be no change in the global variable. That's why it is mandatory over here to use this operator to access global variable.
It prints "John"
Saying you don't want to use "this." is just ridiculous. It takes almost no effort to type and vastly improves code quality.
If you don't want to follow Java standards for code style, use inName and then name = inName; or somesuch.