Question

Possible Duplicate:
Why use getters and setters?

I have been seeing contsructors for a while now,I still dont know how things like this work,I have little knowledge of java and I know they are getters and setters but which function exactly do they perform in my code because it seems its just referring to itself not performing a specific block of code
I just need a very simple explanation,Not seeking debates.

public class RSSItem {

    // All <item> node name
    String _title;
    String _link;
    String _description;
    String _pubdate;
    String _guid;

    // constructor
    public RSSItem(){

    }

    // constructor with parameters
    public RSSItem(String title, String link, String description, String pubdate, String guid){
        this._title = title;
        this._link = link;
        this._description = description;
        this._pubdate = pubdate;
        this._guid = guid;
    }

    /**
     * All SET methods
     * */
    public void setTitle(String title){
        this._title = title;
    }

    public void setLink(String link){
        this._link = link;
    }

    public void setDescription(String description){
        this._description = description;
    }

    public void setPubdate(String pubDate){
        this._pubdate = pubDate;
    }


    public void setGuid(String guid){
        this._guid = guid;
    }

    /**
     * All GET methods
     * */
    public String getTitle(){
        return this._title;
    }

    public String getLink(){
        return this._link;
    }

    public String getDescription(){
        return this._description;
    }

    public String getPubdate(){
        return this._pubdate;
    }

    public String getGuid(){
        return this._guid;
    }
}

Answer 1

The constructor is performing the initialisation of the object in one atomic operation. When you call a constructor, upon return you have a completely created object. Compare this with a simple no-args constructor, followed by a chain of setters. In this scenario you can easily create an object incompletely.

Should you use an intelligent constructor taking args and building the object completely rather than a series of setters ? Generally, yes. Here’s why:

1. the operation is atomic and will give you a complete, correct object (I’m assuming you validate the inputs)
2. you can provide overrides to create objects from fields, strings/streams etc.
3. by using the final field you can create immutable objects. This is very useful for determining reliability (especially wrt. threads) and for debugging issues.

Generally I view sets of setters/getters as poor OO design. At their most basic they merely expose internal fields. You can provide validation etc., but you’re still potentially exposing the implementation.

I would rather instantiate the object using a constructor, and then ask it to do things for me using well-defined methods, rather than pulling the data out via getters and doing it myself. This is the overall aim of OO – telling objects to do things for you rather than asking them for data and doing it yourself.