this

hi all ,
I can't understand the usages of "this" , could you plz help me ?

thank you . . .

On 12-04-28 09:33 AM, mojde wrote:
> hi all ,
> I can't understand the usages of "this" , could you plz help me ?
>
> thank you . . .

One way of understanding "this" is as part of a larger picture, which is
understanding what everything is doing at runtime, i.e. when your code
is executing.

Once you've fired up a Java application, and execution of code starts
with a proper main() method in a designated main class [1], objects with
various lifetimes start to be created. Code in _instance_ methods (as
opposed to static/class methods) runs in the context of a single object.

It's this single object that you can refer to as "this". Understand also
that often, by well-defined rules, you can omit the explicit "this".

A "this" reference (implicit or explicit) is how you affect the state of
the object that your instance methods are executing in. See above: when
an instance method executes it is in the context of one object. Getters
and setters, for example, wouldn't be very useful unless they could
access the state of the particular object. Getters and setters are
simple instance methods themselves.

Without the "this" reference you effectively lose encapsulation. You'd
have to make your member fields public, and there really wouldn't be
instance methods anymore as you'd have to pass object references around
and that would be useless.

As an example, consider a rudimentary class Vehicle as

public class Vehicle {
private Double speed;

public Double getSpeed() { return speed; }
public void setSpeed(Double speed) { this.speed = speed; }
}

Those 2 accessor methods are instance methods - whenever that code
executes they have a context of a single, instantiated Vehicle object.
So for example,

Vehicle vehicle1 = new Vehicle();
vehicle1.setSpeed(15.5);

When you call setSpeed() on "vehicle1", the 'this' reference in the
method body is how the code can access the member field "speed", by
'this.speed', and actually set the value.

The getter _implicitly_ uses 'this'.

If you didn't have 'this', things would degrade to

public class Vehicle {
public Double speed;
}

and

Vehicle vehicle1 = new Vehicle();
vehicle1.speed = 15.5;

There is another usage of 'this' for invoking another constructor from a
constructor of the same class, but I won't cover that right now.
Although in a conceptual sense it's yet another mechanism for accessing
something belonging to the current object.

AHS

1. A codebase can have any number of "main" classes. As many of those
that the codebase has, is how many individual Java applications the
codebase supports.
--
A fly was very close to being called a "land," cause that's what they do
half the time.
-- Mitch Hedberg

In article
<6cab49af-72f5-4bb4-87f8-7eb2e6330b05@t23g2000yqd.googlegroups.com>,
mojde <mojdeyazdi@gmail.com> wrote:

> I can't understand the usages of "this", could you please help me?

See "Using the this Keyword"

<http://docs.oracle.com/javase/tutorial/java/javaOO/thiskey.html>

--
John B. Matthews
trashgod at gmail dot com
<http://sites.google.com/site/drjohnbmatthews>

On Sat, 28 Apr 2012 05:33:59 -0700 (PDT), mojde <mojdeyazdi@gmail.com>
wrote, quoted or indirectly quoted someone who said :

>I can't understand the usages of "this" , could you plz help me ?

see http://mindprod.com/jgloss/this.html
--
Roedy Green Canadian Mind Products
http://mindprod.com
Programmers love to create simplified replacements for HTML.
They forget that the simplest language is the one you
already know. They also forget that their simple little
markup language will bit by bit become even more convoluted
and complicated than HTML because of the unplanned way it grows.
..

mojde <mojdeyazdi@gmail.com> writes:
>I can't understand the usages of "this" , could you plz help me ?

A non-static method »m« may act as a non-static method of an
object »o«. »this« designates this object »o« within the
declaration of the method »m«.

In other words: When a method named »m« was being activated by
a call »o.m(...)«, wherin »o« is an expression of reference
type which has the non-null reference »r« as its value, then,
within the declaration of the method »m«, »this« designates
this reference »r« during the evaluation of any such call.

On 4/28/2012 9:33 PM, mojde wrote:
> hi all ,
> I can't understand the usages of "this" , could you plz help me ?
>
> thank you . . .

if you write a class like this:

class Apple { String color = "";
setColor(String s) { this.color = s }
}

then say you have two apple objects:

Apple a1 = new Apple();
Apple a2 = new Apple();

then when you encounter a statement that says:

a1.setColor("red");

the code for a1.setColor encounters "this.color" which refers to that
object's own color variable.

Why?

Because some people do this:

class Apple { String color = "";
setColor(String color) { this.color = color }
}

Notice now that "this.color" refers to the object's color variable, and
"color" refers to String color in the scope of the local method.

There are other reasons. You may want a class to store a handle of
itself somewhere else. For example, the following method:

public Apple getInstance() { return this }

The above method returns the particular instance of Apple. In this case,

Apple a1 = new Apple;

Now, the following two statements produce identical results:

Apple a2 = a1;
and
Apple a2 = a1.getInstance();

You can also use this to call alternate constructors.
For example;

Apple () { this("red") }
Apple (String s) ( setColor(s) }

One of the more interesting usages of "this" remains passing a reference
to an object versus defining scope. It can be used to create a way to
pass a function as an argument. For example, if we have a well-known
function name encapsulated as a class (think "Thread", "Runnable", or
"Callable"):

class Callable { callme(Object o) { /* code here */ } }

class Println extends Callable { callme(Object o) { println(o); } }
class Print extends Callable { callme(Object o) { print(o); } }

Now you can instantiate an instance of CallableFunction, and pass it as
an argument.
Println p1 = new Println();
Print p2 = new Print();

String = "whatever"
Callable func = new Print();

processcommand (func, whatever);

The code for process command would be as follows, of course:

processcommand(Callable c, Object o)
{ c.callme(o); }

This has applications all over the place from parsing XML to storing
game tree data for a chess file editor, for example, which would allow
you to traverse back and forth in a tree simply by following the
commands contained in the command-nodes which comprise the tree. The
main use here is in processing large numbers of commands. if you have a
switch statement, for example, containing fifty cases, you might begin
to wonder if this method finds a result faster, since it directly looks
up a reference to the code you need to execute (plus one or two extra
method calls).

So for example if you're writing a fighting video game you can't be slow
and have 100 if's or a switch for determining which move to animate
next; you need to get the move immediately and process it.

Also it helps you contain the code in one place; if you use a switch,
there's no guarantee you won't need another separate switch statement
somewhere else if you need new functionality. Using this method I've
described you can just write a default behavior into a base class.

Like lets say your writing a database which searches through a million
chess games. Say for AI. And you need to traverse a lot of game trees
and rotate positions and stuff like that. You pretty much have to use
the this keyword. So it does have it's uses, but for run of the mill
everyday programming it's safer to just use a simple 5 or 10 case
switch. Or not. Or whatever.

Tsukino Usagi wrote:
....
> One of the more interesting usages of "this" remains passing a reference to an
> object versus defining scope. It can be used to create a way to pass a
> function as an argument. For example, if we have a well-known function name

Excellent example for several reasons.

> encapsulated as a class (think "Thread", "Runnable", or "Callable"):
>
> class Callable { callme(Object o) { /* code here */ } }

Quibble: This should be an interface, not a class, and we should declare
pedagogical examples 'public', and most certainly the method should be:

/* not to be confused with
<http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/Callable.html>
*/
public interface Callable<T>
{
void callMe(T client);
}

> class Println extends Callable { callme(Object o) { println(o); } }

public class Println implements Callable<Object>
{
@Override
public void callMe(Object client)
{
System.out.println(client);
}
}

The pattern of single abstract method (SAM) interfaces is so prevalent and
useful that Java will introduce a sort-of functional syntax for it in Java 8.

--
Lew
Honi soit qui mal y pense.
http://upload.wikimedia.org/wikipedi.../c/cf/Friz.jpg