Java :Setter Getter and constructor

Question

I'm a bit confused about the use of getter/setters and constructors (see the below code for an example)

    public class ExampleClass {

        private int value = 0; 

        public ExampleClass () {
            value = 0; 
        }

        public ExampleClass (int i) {
            this.value = i;
        }

        public int getValue() {
            return value; 
        }

        public void setValue(int val) {
            this.value = val; 
        }

        public static void main(String[] args) {     
            ExampleClass example = new ExampleClass (20);
            example.setValue(20); 
            //Both lines above do same thing - why use constructor? 
            System.out.println(example.getvalue());
        }
   }

All I've learned is that we need getters/setters for security and that they can also be used to change or edit values later on.

My question is that if the constructor is the point of initialization and a default constructor is always present, why use a constructor with parameters to initialize values instead of getters/setters?. Wouldn't using the getter and setter provide security as well being able to easily change values at any stage. Please clarify this point for me.

Answer 1

default constructor is always there

Well actually its not always there. A default constructor is the one which is provided by the compiler (of course it is a no-arg constructor ) Only if there is no other constructor defined in the class

why we use constructor with parameters to initialize values instead of set get

Because there could be a condition that an object can always be created only when all the values are provided at the time of initialization itself and there is no default value. So all values must be provided otherwise code will not compile.

Consider this Book class

public class Book {

    private String title;
    private String author;

    public Book(String title, String author){
        this.title = title;
        this.author = author;
    }
     //getters and setters here 
}

Consider a condition where a book can be created only if it has title and author.

• You cannot do new Book() because no-arg constructor is absent and compiler will not provide one because one constructor is already defined.
• Also you cannot do new Book() because our condition does not meet as every book requires a title and author.

This is the condition where parameterized constructor is useful.

Answer 2

Sometimes, when creating a new object of a class, some values HAVE TO be provided. For an example, when connecting to database and creating Connection class object you have to provide a connection string, so that it knows what are you connecting to. Creating new connection without specyfing target database would be pretty useless, right?

Also, take a look at this

Foo foo=new Foo(1,2,3,4,5,6,7);

and this

Foo foo=new Foo();
foo.setP1(1);
foo.setP2(2);
foo.setP3(3);
foo.setP4(4);
foo.setP5(5);
foo.setP6(6);
foo.setP7(7);

First one looks better, right?

Answer 3

My question is that if constructor is point of initialization and default constructor is always there so why we use constructor with parameters to initialize values instead of set get.

If you think about an object transitioning into different states then it makes sense to have a parameterized constructor alongwith setters and getters. Let me try to put a real life scenario: Think about an Employee class, a new employee joins, you don't know many details but few and you create the object of Employee with defualt and base value of its attributes. You need to register the employee in the system and hence you used the parameterized constructor. Once you get more details about the employee, you use getters and setters to update the attributes.

Answer 4

this is purely upto your coding style. But IMO, I would use parametrized constructor:

1. to initialize those values which should not be changed. (like username parameter for a person object)

2. to initialize those values, without setting which, the object will be in invalid state.

Say, you are sending login parameters to a method. You can use in these to ways

Login obj = new Login();
obj.setUsername("user");
obj.setPassword("pw")// what if someone commented this out, or you forget to call it


and otherway,
Login obj = new Login("user", "pw");

while you can send Login object just after setting username in 1st case, it would be invalid at recieving end. but the second method is less prone to bugs, bcz it becomes necessary to pass all the required parameters.

Answer 5

Just to make it easier. It takes less code to use a constructor than to create an object and use the setters.

Answer 6

Sometimes you don't need to set all the fields to specific values at the time of creating. For examle, when you make an array. Also, as already said, it's safer when you use getters -- you can't get nullpointer.

Remember to write the default constructor when you've defined constructor with parameters. Or be sure not to use it.

Answer 7

First, both methods: Constructor and Setter are safe ways to change object's attributes. Are expected from Class author to expose or not safe ways to modify an instance.

1. The default constructor is always provided if you have not written one:

   // Example of a Class with a Default Constructor 
   public class GetSet {
   
       private String value;
   
       public String getValue() {
           return value;
       }
       public void setValue(String value) {
           this.value = value;
       }
   
   
       public static void main(String[] args) {
           // Theres a implicit Default Constructor here
           // Its ok to do that
           // GetSet obj = new GetSet();
           GetSet obj = new GetSet();
       }
   
   }
   
   
   // Example of a Class without a Default Constructor 
   public class GetSet2 {
   
       public GetSet2(String value) {
           this.value = value;
       }
   
       private String value;
   
       public String getValue() {
           return value;
       }
       public void setValue(String value) {
           this.value = value;
       }
   
       public static void main(String[] args) {
           // GetSet2 obj = new GetSet2(); // compile time error
           // Default constructor is not provided, since u wrote one
       }
   
   }
   

2. About which is better: Using a constructor or via setter, it depends on what u want. If you will only modify an attribute of a existing object, u may use the setter, or for a completely filled object you may prefer the constructor instead.

    // Example of modifing an obj via Setter and Constructor
    public class GetSet3 {

        public GetSet3(String value1, String value2, String value3, String value4) {
            this.value1 = value1;
            this.value2 = value2;
            this.value3 = value3;
            this.value4 = value4;
        }

        private String value1;
        private String value2;
        private String value3;
        private String value4;


        // ... Getters and Setters



        public static void main(String[] args) {

            // Its easier to this
            GetSet3 obj;

            obj= new GetSet3("j", "a", "v", "a");

            // instead that
            // its also easy to forget or do something wrong
            // when u have a lot of attributes to set
            obj.setValue1("j");
            obj.setValue2("a");
            obj.setValue3("v");
            obj.setValue4("a");

        }
    }

Answer 8

It's easier and safer to initialize your object variables via your constructor to avoid nullpointers.

If you instantiate your object without initializing your variables first and you do a get operation on one of your null variables, you might get a nullpointer exception at runtime because you forgot to manually set its value.

On the flipside of that, if you always initialize your object variables in your default constructor, you have a seriously reduced risk of getting nullpointer exceptions during runtime because none of your variables can be null unless you specifically set them via a setter (which is not recommended).

Answer 9

Constructor with arguments makes you get the object fully constructed. If you want to use default one, you will have to make sure the fields are set using setters. During set of some property, assume the exception is thrown, now you have an object which is not usable. In several cases, setter wouldn't be exposed but getters. In those cases, having constructor with arguments or a named constructor is the right option. In a nutshell, getters and setters do have their own importance rather than initializing the object.

Why use getters and setters?

Answer 10

Because you write it using less, more elegant and better readable code when you set the values as parameters in a constructor. Moreover, sometimes some fields are indispensable for the object, so a parameter constructor prevents the user from creating an object omitting necessary fields for the object's functionality. One is though not "oblidged" to call the setters.

Answer 11

To answer this question, I say by writing getters/setters, we create a provision to add any validation method in the future, currently, there is no validation, but if anything goes wrong in the future we just add validation logic in the setter.

we can also write the logic/validation in constructors but it's not a good practice. The constructor should be used only to initialize your object's state/fields. You should delegate the responsibility of other things to other methods. Note that a constructor is called only once i.e, whenever you create a new object With a sufficiently large input, you can cause an exception in your constructor. This is one of several reasons why you should not use a constructor to contain "business logic".