Q:

Accessor Methods in Java

So I have a question on "setter" and "getter" methods and how useful they are or aren't.
Let's say I just write a very basic program like the following:
    public class Account
    {
     String name;
     String address;
     double balance; 
    }

Then, let's say I write another class that uses this "Account" class, like the following:
    class UseAccount
    {
        public static void main(String[] args)
        {
            Account myAccount = new Account();
            Account yourAccount = new Account();

            myAccount.name = "Blah blah"
        }        
    }

etc., etc.
When I write myAccount.name = "Blah blah", I am changing the value of the variable "name" in the "Account" class.  I am free to do this as many times as I like with the code written the way it is.  It has come to my attention, however, that it's better practice to make the variables in the "Account" class private, and then use "setter" and "getter" methods.  So if I write the following:
    public class Account
    {
       private String name;
       private String address;
       private String balance;

       public void setName(String n)
       {
          name = n;
       }

       public String getName()
       {
          return name;
       }
    }

I can still change the value of the variable "name" by just creating another class that has something like:
    class UseAccount
    {
       public static void main(String[] args)
       {
          Account myAccount = new Account();

          myAccount.setName("Blah blah");
       }
    }

I don't understand how using this method is any different or is supposed to prevent people form changing the value of a private field.  Any help?

A:

With trivial accessor methods, there is no difference except style, but you can also execute code with them, for example:
public void setName(String name) {
    if (name == null) {
        throw new IllegalArgumentException("Name may not be null");
    }
    this.name = name;
}

You can also return copies from a getter, thus protecting your data:
private List<String> middleNames;
public List<String> getMiddleNames() {
    return new ArrayList<String>(middleNames); // return a copy
    // The caller can modify the returned list without affecting your data
}

These are just two simple examples, but there are limitless examples of how accessor methods can be used.
It is better to follow a consistent style, so that's why we always use getters/setters - so code this like may be executed if needed.

A:

Try this Golden Rule of Object Oriented Programming.
1. Create private Instance variables.
2. Create public getters and setters to access those Instance variable.
3. This methodology is called Encapsulation. Though Encapsulation can be used in a different
   way, that has importance in Design Patterns, Like Those Behaviors which keeps changing must
   be encapsulated in an Abstract Class or Interfaces.
4. Well now back to the topic of Getter and Setter....
Getter and Setter helps Validating the Input to the Instance Variable.
For eg:
           Assume i got a method to assign the Age of the Dog, Now the age can NoT be negative, If i dont have setter method, then i will not be able to Validate the Input of age.
private int age;

public void setDogAge(int age){ 
    if (age>0){
        this.age = age;
    } 
    else{
        System.out.println("Please Enter a Valid Age");
    }
}

