When to use "this." when not to ?

Question

Hi, I know this will be a basic question, but can someone tell me the rule of when to use this.method/variable/etc and when not to ?
If I have (And I'll cut down the code,leaving construtors, etc.)
public abstract class DataStuff
protected String message = null;
protected void clearMessage()
this.message = null; // Do I use this.
message = null; // Or not ?
} // End clearMessage()
} // End Class ---------
Lets get more complicated
public class MoreStuff extends DataStuff
public void someMethod()
this.message = "Do I use This ?";
message = "Or Do I not ?";
this.clearMessage(); // or
clearMessage();
} // End someMethod()
} // End Class ------
I know this will be fairly simple, and I am sure there are lots of Tutorials I could not find that explain the difference between "this"
thanks
Paul

Answer 1

Besides using the this reference for instance variables that have the same name as a local variable, it is also used when your class implements an interface and uses it in the class. Let me further explain. Lets pretend that you create a JFrame that has buttons on it. You want your buttons to handle events so you add an ActionListener to the buttons. You also want to code your event handling in the JFrame so you cause your JFrame to implement the ActionListener interface and implement the required method actionPerformed() in your JFrame class. Well, when you add and actionListener to the buttons, you have to use the this reference in the method signature. See code for example.import javax.swing.*;
import java.awt.event.*;
import java.awt.*;
public class ExampleJFrame extends JFrame implements ActionListener {
   public ExampleJFrame() {
      super("Example using 'this' reference!");
      Container c = getContentPane();
      JButton button = new JButton("Push Me");
      /* Here is the example of how the 'this' reference is
         used.  Since this class implements ActionListener,
         that means it is an ActionListener.  So, when
         we add the method addActionListener to the button,
         it requires that an ActionListener be put into
         the method signature.  So, I just pass a reference
         to this class into it (using the 'this' reference).
         Its actionPerformed method will be called.  There
         are 3 ways I could think of to handle the
         events for this button.  One is to do it the way
         I chose to do it; that is, have the originating
         class (ExampleJFrame) handle it.  That is where
         the 'this' reference comes into play.  Two is
         to use an anonymous inner class.  The second
         option is useful if the code is small and
         self contained.  Three is to have another
         class handle it, such as an Action. */
      button.addActionListener(this);
      c.add(button);
      /* incidentally, you could put the this keyword in
         front of each of these methods for readability,
         but most people don't. I used it on the first
         one to demonstrate it.  */
               //cause the program to end when closing
      this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
      pack();
      setVisible(true);
   }//end constructor
   /*=**************************************************
   * actionPerformed(): required ActionListener method *
   public void actionPerformed(ActionEvent e) {
      /* the this reference is also used in here because
         the showMessageDialog() should have as its
         parent a component and we want the component to
         be this JFrame */
      JOptionPane.showMessageDialog(this,"You used the this pointer!");
   }//end actionPerformed
   public static void main(String args[]) {
      /* when you run this class, a small JFrame with
         a button will appear in the top left corner. */
      ExampleJFrame app = new ExampleJFrame();
   }//end main
}//end ExampleJFrame classtajenkins