public class Foo {
private String name;
// ...
public void setName(String name) {
// This makes it clear that you are assigning
// the value of the parameter "name" to the
// instance variable "name".
this.name = name;
}
// ...
}
Here this keyword is acting as reference variable of current class object. But, where this object is getting created? To which object this keyword is referencing? What'sthe logic?
It's "whatever object the method was called on". We can't tell where the object is created, because that's presumably in some other code.
Have a look at this simple, complete example:
class Person {
private final String name;
public Person(String name) {
// this refers to the object being constructed
this.name = name;
}
public void printName() {
// this refers to the object the method was called on
System.out.println("My name is " + this.name);
}
}
public class Test {
public static void main(String[] args) {
Person p1 = new Person("Jon");
Person p2 = new Person("Himanshu");
p1.printName(); // Prints "My name is Jon"
p2.printName(); // Prints "My name is Himanshu"
}
}
The first time we call printName(), we call it on the object that p1 refers to - so that's the object that this refers to within the method, and it prints the name Jon. The second time we call printName(), we call it on the object that p2 refers to - so that's the object that this refers to within the method, and it prints the name Himanshu.
(It's important to note that p1 and p2 aren't objects themselves - they're variables, and the values of the variables aren't objects either, but references. See this answer for more details about that difference.)
When we use the "this" refers to own class and the current instance of the class.
When programming for Android is very common to see the use of this with the class and not just attributes.
In a method of MainActivity class:
SlidingMenuAdapter slidingMenuAdapter = new SlidingMenuAdapter(MainActivity.this, listSliding);
or just
SlidingMenuAdapter slidingMenuAdapter = new SlidingMenuAdapter(this, listSliding);
The this keyword refers to the current instance of the class. Using your class Foo here is how you can look at it:
// We create an instance of the class here
public Foo myFoo;
In your class here is what is going to happen at the high level.
public void setName(String name) {
// this.name = name;
// will be interpreted as when you call myFoo.setName(name);
// myFoo.name = name
}
You can use your debugger if you want to have an idea of how the compiler represents your objects.
Related
Consider the following:
public class Foo {
private String name;
public Foo(String name) {
this.name = name;
}
public String get() {
return name;
}
public void set(String name) {
this.name = name;
}
}
import java.util.ArrayList;
A container class:
public class FooContainer {
private ArrayList<Foo> foos;
public FooContainer(int nbrOfFoos) {
foos = new ArrayList<Foo>(nbrOfFoos);
}
public void add(Foo foo) {
foos.add(foo);
}
public void printFoos() {
for(Foo foo: foos) {
System.out.println(foo.get());
}
}
}
A simple test:
public class FooTest {
public static void main(String[] args) {
Foo foo = new Foo("Long");
FooContainer cont = new FooContainer(1);
cont.add(foo);
cont.printFoos();
foo.set("John");
cont.printFoos();
}
}
Of course, when executed, the test program prints "Long" and then "John".
Is it poor design to have a program where this is not desirable, i.e. where one would not like the name of the Foo to change?
Is the only workaround to copy/clone the object when passed to the add method?
That's the way Java works: Objects are passed as reference and not as copies. In most cases, this seems to make sense. Copying an object can be expensive. If you want to put a copy into the container, you need to explicitly create a new object - I would not consider this a workaround.
If your point is mainly about preventing an existing object from being modified, you could make it immutable, i.e. make 'name' final and remove the 'set' method.
Just for clarification, Java always pass parameters as values. The misunderstanding comes as Java pass a copy of the reference thus it appears that an object is passed by reference.
Read this question to learn more: Is Java "pass-by-reference" or "pass-by-value"?
This question already has answers here:
When should I use "this" in a class?
(17 answers)
Closed 7 years ago.
I'm trying to get an understanding of what the the java keyword this actually does.
I've been reading Sun's documentation but I'm still fuzzy on what this actually does.
The this keyword is a reference to the current object.
class Foo
{
private int bar;
public Foo(int bar)
{
// the "this" keyword allows you to specify that
// you mean "this type" and reference the members
// of this type - in this instance it is allowing
// you to disambiguate between the private member
// "bar" and the parameter "bar" passed into the
// constructor
this.bar = bar;
}
}
Another way to think about it is that the this keyword is like a personal pronoun that you use to reference yourself. Other languages have different words for the same concept. VB uses Me and the Python convention (as Python does not use a keyword, simply an implicit parameter to each method) is to use self.
If you were to reference objects that are intrinsically yours you would say something like this:
My arm or my leg
Think of this as just a way for a type to say "my". So a psuedocode representation would look like this:
class Foo
{
private int bar;
public Foo(int bar)
{
my.bar = bar;
}
}
The keyword this can mean different things in different contexts, that's probably the source of your confusion.
It can be used as a object reference which refers to the instance the current method was called on: return this;
It can be used as a object reference which refers to the instance the current constructor is creating, e.g. to access hidden fields:
MyClass(String name)
{
this.name = name;
}
It can be used to invoke a different constructor of a a class from within a constructor:
MyClass()
{
this("default name");
}
It can be used to access enclosing instances from within a nested class:
public class MyClass
{
String name;
public class MyClass
{
String name;
public String getOuterName()
{
return MyClass.this.name;
}
}
}
"this" is a reference to the current object.
See details here
The keyword this is a reference to the current object. It's best explained with the following piece of code:
public class MyClass {
public void testingThis()
{
// You can access the stuff below by
// using this (although this is not mandatory)
System.out.println(this.myInt);
System.out.println(this.myStringMethod());
// Will print out:
// 100
// Hello World
}
int myInt = 100;
string myStringMethod()
{
return "Hello World";
}
}
It's not used a lot unless you have code standard at your place telling you to use the this keyword. There is one common use for it, and that's if you follow a code convention where you have parameter names that are the same as your class attributes:
public class ProperExample {
private int numberOfExamples;
public ProperExample(int numberOfExamples)
{
this.numberOfExamples = numberOfExamples;
}
}
One proper use of the this keyword is to chain constructors (making constructing object consistent throughout constructors):
public class Square {
public Square()
{
this(0, 0);
}
public Square(int x_and_y)
{
this(x_and_y, x_and_y);
}
public Square(int x, int y)
{
// finally do something with x and y
}
}
This keyword works the same way in e.g. C#.
An even better use of this
public class Blah implements Foo {
public Foo getFoo() {
return this;
}
}
It allows you to specifically "this" object in the current context. Another example:
public class Blah {
public void process(Foo foo) {
foo.setBar(this);
}
}
How else could you do these operations.
"this" keyword refers to current object due to which the method is under execution. It is also used to avoid ambiguity between local variable passed as a argument in a method and instance variable whenever instance variable and local variable has a same name.
Example ::
public class ThisDemo1
{
public static void main(String[] args)
{
A a1=new A(4,5);
}
}
class A
{
int num1;
int num2;
A(int num1)
{
this.num1=num1; //here "this" refers to instance variable num1.
//"this" avoids ambigutiy between local variable "num1" & instance variable "num1"
System.out.println("num1 :: "+(this.num1));
}
A(int num, int num2)
{
this(num); //here "this" calls 1 argument constructor within the same class.
this.num2=num2;
System.out.println("num2 :: "+(this.num2));
//Above line prints value of the instance variable num2.
}
}
The keyword 'this' refers to the current object's context. In many cases (as Andrew points out), you'll use an explicit this to make it clear that you're referring to the current object.
Also, from 'this and super':
*There are other uses for this. Sometimes, when you are writing an instance method, you need to pass the object that contains the method to a subroutine, as an actual parameter. In that case, you can use this as the actual parameter. For example, if you wanted to print out a string representation of the object, you could say "System.out.println(this);". Or you could assign the value of this to another variable in an assignment statement.
In fact, you can do anything with this that you could do with any other variable, except change its value.*
That site also refers to the related concept of 'super', which may prove to be helpful in understanding how these work with inheritance.
It's a reference of actual instance of a class inside a method of the same class.
coding
public class A{
int attr=10;
public int calc(){
return this.getA()+10;
}
/**
*get and set
**/
}//end class A
In calc() body, the software runs a method inside the object allocated currently.
How it's possible that the behaviour of the object can see itself? With the this keyword, exactly.
Really, the this keyword not requires a obligatory use (as super) because the JVM knows where call a method in the memory area, but in my opinion this make the code more readeable.
It can be also a way to access information on the current context.
For example:
public class OuterClass
{
public static void main(String[] args)
{
OuterClass oc = new OuterClass();
}
OuterClass()
{
InnerClass ic = new InnerClass(this);
}
class InnerClass
{
InnerClass(OuterClass oc)
{
System.out.println("Enclosing class: " + oc + " / " + oc.getClass());
System.out.println("This class: " + this + " / " + this.getClass());
System.out.println("Parent of this class: " + this.getClass().getEnclosingClass());
System.out.println("Other way to parent: " + OuterClass.this);
}
}
}
Think of it in terms of english, "this object" is the object you currently have.
WindowMaker foo = new WindowMaker(this);
For example, you are currently inside a class that extends from the JFrame and you want to pass a reference to the WindowMaker object for the JFrame so it can interact with the JFrame. You can pass a reference to the JFrame, by passing its reference to the object which is called "this".
Every object can access a reference to itself with keyword this (sometimes called the this
reference).
First lets take a look on code
public class Employee {
private int empId;
private String name;
public int getEmpId() {
return this.empId;
}
public String getName() {
return this.name;
}
public void setEmpId(int empId) {
this.empId = empId;
}
public void setName(String name) {
this.name = name;
}
}
In the above method getName() return instance variable name.
Now lets take another look of similar code is
public class Employee {
private int empId;
private String name;
public int getEmpId() {
return this.empId;
}
public String getName() {
String name="Yasir Shabbir";
return name;
}
public void setEmpId(int empId) {
this.empId = empId;
}
public void setName(String name) {
this.name = name;
}
public static void main(String []args){
Employee e=new Employee();
e.setName("Programmer of UOS");
System.out.println(e.getName());
}
}
Output
Yasir Shabbir
this operator always work with instance variable(Belong to Object)
not any class variable(Belong to Class)
this always refer to class non static attribute not any other parameter or local variable.
this always use in non static method
this operator cannot work on static variable(Class variable)
**NOTE:**It’s often a logic error when a method contains a parameter or local variable that has the
same name as a field of the class. In this case, use reference this if you wish to access the
field of the class—otherwise, the method parameter or local variable will be referenced.
What 'this' does is very simply. It holds the reference of current
object.
This keyword holds the reference of instance of current class
This keyword can not be used inside static function or static blocks
This keyword can be used to access shadowed variable of instance
This keyword can be used to pass current object as parameter in function calls
This keyword can be used to create constructor chain
Source: http://javaandme.com/core-java/this-word
A small segment of testing code as follows:
class Teacher {
private String title;
String name = "A";
int age = 20;
Teacher (String title) {
//System.out.println(name);
this(name,age,title);
}
Teacher (String name, int age, String title) {
System.out.println("OK");
}
}
public class Test {
public static void main (String[] args) {
Teacher teacher1 = new Teacher("John");
Teacher teacher2 = new Teacher("Mike",25,"TA");
}
}
As above, I annotated System.out.println(name); After compiling, there was an error:Can't reference name(age) before the superclass constructor has been called. However, I annotated this(name,age,title);, which meant I only used System.out.println(name);. And the error was gone. Thus, I think the name and age has been initialized and get the value A,20. That is to say, this(name,age,title) is actually this("a",20,"John") I don't know the principle. Need your help.
this/super constructor call has to be the first statement when you chain constructor call. See this for details.
The principle is,
If present, the invocation of another constructor must be the first
line in the constructor.
Reference : JavaDoc
Using this keyword you are invoking other constructor.
When you comment out the first statement, the constructor call becomes first line which is legal.
Java Documentation says that
If present, the invocation of another constructor must be the first line in the constructor.
You can't access the fields name and age when calling this(). The fields have not been initialized yet. If you want name to be "A" by default and age to be 20, enter the values directly as parameters to this().
The following class will compile:
class Teacher {
private String title;
String name;
int age;
Teacher (String title) {
this("A",20,title);
}
Teacher (String name, int age, String title) {
this.name = name;
this.age = age;
System.out.println("OK");
}
}
I am new to java.
I want to know how I can use the variable in the whole java class and keeping the value of it. Suppose in a method I fill the variable with a value and I want to use the value of it in another method.
public class Test {
public String id;
public void includeClient() {
String id = baseClass.createCleint();
}
public void removeClient() {
System.out.println(id);
}
}
in second function it returns null. Any idea?
In the method includeClient() you assigned the value to a local variable having the same name as the instance variable. The other method (which, BTW, can't have the same signature as the first method) sees the instance variable, which is still null.
Change it to :
public void includeClient() {
id = baseClass.createCleint();
}
Remove String from String id = baseClass.createCleint(); as it is local variable for the method and will be assiged the value when you call method and garbage collected after the execution of method and not accessible outside the method.
In short you are not assigning value to the variable declared at class level but you are creating another one.You better use Constructor to perform initialization.
Secondly you have declare public void includeClient() { twice I bet it's typo.
public class Test {
public String id;
public void includeClient() {
id = baseClass.createCleint();
}
}
public class Test {
public String id;
public void includeClient() {
String id2 = baseClass.createCleint();
System.out.println(id2);
id = id2;
}
public void includeClient2() {
System.out.println(id);
}
}
Use this to understand and test.
List of changes made -
Changed second method name to make it unique
Assigned return value to local variable named different than class member variable.
First print return value to check what it is returning
Assign local value to member variable.
Note: You still need to read a lot about java. Just keep practicing.
Replace:
String id = baseClass.createCleint();
by
this.id = baseClass.createCleint();
or
id = baseClass.createCleint();
An important thing to note about this is that there's two ways to share a variable like this - you can have each object of the class have its own copy of the variable, or you can have every object of the class share the same one variable. The keyword static lets you do the latter:
class Test {
public String message;
}
class TestStatic {
public static String message;
}
If you have instances of the first class, they behave like each instance has its own message:
Test testA = new Test();
Test testB = new Test();
testA.message = "Hello!";
testB.message = "Greetings!";
System.out.println(testA.message);
System.out.println(testB.message);
But with the second class, what happens is that the class itself has a message and all instances of the class refer to it, so there's only one message that's shared between all of them:
TestStatic testA = new TestStatic();
TestStatic testB = new TestStatic();
TestStatic.message = "Hello!";
System.out.println(testA.message);
System.out.println(testB.message);
Note that we didn't set message using either testA.message or testB.message as above - we set it using the class with TestStatic.message. This is because message doesn't really belong to either testA or testB, it belongs to the class and testA and testB simple have access to their class's members.
This question already has answers here:
When should I use "this" in a class?
(17 answers)
Closed 7 years ago.
I'm trying to get an understanding of what the the java keyword this actually does.
I've been reading Sun's documentation but I'm still fuzzy on what this actually does.
The this keyword is a reference to the current object.
class Foo
{
private int bar;
public Foo(int bar)
{
// the "this" keyword allows you to specify that
// you mean "this type" and reference the members
// of this type - in this instance it is allowing
// you to disambiguate between the private member
// "bar" and the parameter "bar" passed into the
// constructor
this.bar = bar;
}
}
Another way to think about it is that the this keyword is like a personal pronoun that you use to reference yourself. Other languages have different words for the same concept. VB uses Me and the Python convention (as Python does not use a keyword, simply an implicit parameter to each method) is to use self.
If you were to reference objects that are intrinsically yours you would say something like this:
My arm or my leg
Think of this as just a way for a type to say "my". So a psuedocode representation would look like this:
class Foo
{
private int bar;
public Foo(int bar)
{
my.bar = bar;
}
}
The keyword this can mean different things in different contexts, that's probably the source of your confusion.
It can be used as a object reference which refers to the instance the current method was called on: return this;
It can be used as a object reference which refers to the instance the current constructor is creating, e.g. to access hidden fields:
MyClass(String name)
{
this.name = name;
}
It can be used to invoke a different constructor of a a class from within a constructor:
MyClass()
{
this("default name");
}
It can be used to access enclosing instances from within a nested class:
public class MyClass
{
String name;
public class MyClass
{
String name;
public String getOuterName()
{
return MyClass.this.name;
}
}
}
"this" is a reference to the current object.
See details here
The keyword this is a reference to the current object. It's best explained with the following piece of code:
public class MyClass {
public void testingThis()
{
// You can access the stuff below by
// using this (although this is not mandatory)
System.out.println(this.myInt);
System.out.println(this.myStringMethod());
// Will print out:
// 100
// Hello World
}
int myInt = 100;
string myStringMethod()
{
return "Hello World";
}
}
It's not used a lot unless you have code standard at your place telling you to use the this keyword. There is one common use for it, and that's if you follow a code convention where you have parameter names that are the same as your class attributes:
public class ProperExample {
private int numberOfExamples;
public ProperExample(int numberOfExamples)
{
this.numberOfExamples = numberOfExamples;
}
}
One proper use of the this keyword is to chain constructors (making constructing object consistent throughout constructors):
public class Square {
public Square()
{
this(0, 0);
}
public Square(int x_and_y)
{
this(x_and_y, x_and_y);
}
public Square(int x, int y)
{
// finally do something with x and y
}
}
This keyword works the same way in e.g. C#.
An even better use of this
public class Blah implements Foo {
public Foo getFoo() {
return this;
}
}
It allows you to specifically "this" object in the current context. Another example:
public class Blah {
public void process(Foo foo) {
foo.setBar(this);
}
}
How else could you do these operations.
"this" keyword refers to current object due to which the method is under execution. It is also used to avoid ambiguity between local variable passed as a argument in a method and instance variable whenever instance variable and local variable has a same name.
Example ::
public class ThisDemo1
{
public static void main(String[] args)
{
A a1=new A(4,5);
}
}
class A
{
int num1;
int num2;
A(int num1)
{
this.num1=num1; //here "this" refers to instance variable num1.
//"this" avoids ambigutiy between local variable "num1" & instance variable "num1"
System.out.println("num1 :: "+(this.num1));
}
A(int num, int num2)
{
this(num); //here "this" calls 1 argument constructor within the same class.
this.num2=num2;
System.out.println("num2 :: "+(this.num2));
//Above line prints value of the instance variable num2.
}
}
The keyword 'this' refers to the current object's context. In many cases (as Andrew points out), you'll use an explicit this to make it clear that you're referring to the current object.
Also, from 'this and super':
*There are other uses for this. Sometimes, when you are writing an instance method, you need to pass the object that contains the method to a subroutine, as an actual parameter. In that case, you can use this as the actual parameter. For example, if you wanted to print out a string representation of the object, you could say "System.out.println(this);". Or you could assign the value of this to another variable in an assignment statement.
In fact, you can do anything with this that you could do with any other variable, except change its value.*
That site also refers to the related concept of 'super', which may prove to be helpful in understanding how these work with inheritance.
It's a reference of actual instance of a class inside a method of the same class.
coding
public class A{
int attr=10;
public int calc(){
return this.getA()+10;
}
/**
*get and set
**/
}//end class A
In calc() body, the software runs a method inside the object allocated currently.
How it's possible that the behaviour of the object can see itself? With the this keyword, exactly.
Really, the this keyword not requires a obligatory use (as super) because the JVM knows where call a method in the memory area, but in my opinion this make the code more readeable.
It can be also a way to access information on the current context.
For example:
public class OuterClass
{
public static void main(String[] args)
{
OuterClass oc = new OuterClass();
}
OuterClass()
{
InnerClass ic = new InnerClass(this);
}
class InnerClass
{
InnerClass(OuterClass oc)
{
System.out.println("Enclosing class: " + oc + " / " + oc.getClass());
System.out.println("This class: " + this + " / " + this.getClass());
System.out.println("Parent of this class: " + this.getClass().getEnclosingClass());
System.out.println("Other way to parent: " + OuterClass.this);
}
}
}
Think of it in terms of english, "this object" is the object you currently have.
WindowMaker foo = new WindowMaker(this);
For example, you are currently inside a class that extends from the JFrame and you want to pass a reference to the WindowMaker object for the JFrame so it can interact with the JFrame. You can pass a reference to the JFrame, by passing its reference to the object which is called "this".
Every object can access a reference to itself with keyword this (sometimes called the this
reference).
First lets take a look on code
public class Employee {
private int empId;
private String name;
public int getEmpId() {
return this.empId;
}
public String getName() {
return this.name;
}
public void setEmpId(int empId) {
this.empId = empId;
}
public void setName(String name) {
this.name = name;
}
}
In the above method getName() return instance variable name.
Now lets take another look of similar code is
public class Employee {
private int empId;
private String name;
public int getEmpId() {
return this.empId;
}
public String getName() {
String name="Yasir Shabbir";
return name;
}
public void setEmpId(int empId) {
this.empId = empId;
}
public void setName(String name) {
this.name = name;
}
public static void main(String []args){
Employee e=new Employee();
e.setName("Programmer of UOS");
System.out.println(e.getName());
}
}
Output
Yasir Shabbir
this operator always work with instance variable(Belong to Object)
not any class variable(Belong to Class)
this always refer to class non static attribute not any other parameter or local variable.
this always use in non static method
this operator cannot work on static variable(Class variable)
**NOTE:**It’s often a logic error when a method contains a parameter or local variable that has the
same name as a field of the class. In this case, use reference this if you wish to access the
field of the class—otherwise, the method parameter or local variable will be referenced.
What 'this' does is very simply. It holds the reference of current
object.
This keyword holds the reference of instance of current class
This keyword can not be used inside static function or static blocks
This keyword can be used to access shadowed variable of instance
This keyword can be used to pass current object as parameter in function calls
This keyword can be used to create constructor chain
Source: http://javaandme.com/core-java/this-word