- Using the this Keyword
- Using this with a Field
- Using this with a Constructor
- Guide to the this Java Keyword
- Get started with Spring 5 and Spring Boot 2, through the Learn Spring course:
- > CHECK OUT THE COURSE
- 1. Introduction
- 2. Disambiguating Field Shadowing
- 3. Referencing Constructors of the Same Class
- 4. Passing this as a Parameter
- 5. Returning this
- 6. The this Keyword Within the Inner Class
- 7. Conclusion
- Пример второй — Применение this для явного вызова конструктора
Using the this Keyword
Within an instance method or a constructor, this is a reference to the current object the object whose method or constructor is being called. You can refer to any member of the current object from within an instance method or a constructor by using this .
Using this with a Field
The most common reason for using the this keyword is because a field is shadowed by a method or constructor parameter.
For example, the Point class was written like this
but it could have been written like this:
Each argument to the constructor shadows one of the object’s fields inside the constructor x is a local copy of the constructor’s first argument. To refer to the Point field x , the constructor must use this.x .
Using this with a Constructor
From within a constructor, you can also use the this keyword to call another constructor in the same class. Doing so is called an explicit constructor invocation. Here’s another Rectangle class, with a different implementation from the one in the Objects section.
public class Rectangle < private int x, y; private int width, height; public Rectangle() < this(0, 0, 1, 1); > public Rectangle(int width, int height) < this(0, 0, width, height); > public Rectangle(int x, int y, int width, int height) < this.x = x; this.y = y; this.width = width; this.height = height; >. >
This class contains a set of constructors. Each constructor initializes some or all of the rectangle’s member variables. The constructors provide a default value for any member variable whose initial value is not provided by an argument. For example, the no-argument constructor creates a 1×1 Rectangle at coordinates 0,0. The two-argument constructor calls the four-argument constructor, passing in the width and height but always using the 0,0 coordinates. As before, the compiler determines which constructor to call, based on the number and the type of arguments.
If present, the invocation of another constructor must be the first line in the constructor.
Guide to the this Java Keyword
As always, the writeup is super practical and based on a simple application that can work with documents with a mix of encrypted and unencrypted fields.
We rely on other people’s code in our own work. Every day.
It might be the language you’re writing in, the framework you’re building on, or some esoteric piece of software that does one thing so well you never found the need to implement it yourself.
The problem is, of course, when things fall apart in production — debugging the implementation of a 3rd party library you have no intimate knowledge of is, to say the least, tricky.
Lightrun is a new kind of debugger.
It’s one geared specifically towards real-life production environments. Using Lightrun, you can drill down into running applications, including 3rd party dependencies, with real-time logs, snapshots, and metrics.
Learn more in this quick, 5-minute Lightrun tutorial:
Slow MySQL query performance is all too common. Of course it is. A good way to go is, naturally, a dedicated profiler that actually understands the ins and outs of MySQL.
The Jet Profiler was built for MySQL only, so it can do things like real-time query performance, focus on most used tables or most frequent queries, quickly identify performance issues and basically help you optimize your queries.
Critically, it has very minimal impact on your server’s performance, with most of the profiling work done separately — so it needs no server changes, agents or separate services.
Basically, you install the desktop application, connect to your MySQL server, hit the record button, and you’ll have results within minutes:
DbSchema is a super-flexible database designer, which can take you from designing the DB with your team all the way to safely deploying the schema.
The way it does all of that is by using a design model, a database-independent image of the schema, which can be shared in a team using GIT and compared or deployed on to any database.
And, of course, it can be heavily visual, allowing you to interact with the database using diagrams, visually compose queries, explore the data, generate random data, import data or build HTML5 database reports.
Get started with Spring 5 and Spring Boot 2, through the Learn Spring course:
> CHECK OUT THE COURSE
1. Introduction
In this tutorial, we’ll take a look at the this Java keyword.
In Java, this keyword is a reference to the current object whose method is being called.
Let’s explore how and when we can use the keyword.
2. Disambiguating Field Shadowing
The keyword is useful for disambiguating instance variables from local parameters. The most common reason is when we have constructor parameters with the same name as instance fields:
As we can see here, we’re using this with the name and age instance fields – to distinguish them from parameters.
Another usage is to use this with the parameter hiding or shadowing in the local scope. An example of use can be found in the Variable and Method Hiding article.
3. Referencing Constructors of the Same Class
From a constructor, we can use this() to call a different constructor of the same class. Here, we use this() for the constructor chaining to reduce the code usage.
The most common use case is to call a default constructor from the parameterized constructor:
public KeywordTest(String name, int age) < this(); // the rest of the code >Or, we can call the parameterized constructor from the no argument constructor and pass some arguments:
Note, that this() should be the first statement in the constructor, otherwise the compilation error will occur.
4. Passing this as a Parameter
Here we have printInstance() method, where the this Keyword argument is defined:
public KeywordTest() < printInstance(this); >public void printInstance(KeywordTest thisKeyword)
Inside the constructor, we invoke printInstance() method. With this, we pass a reference to the current instance.
5. Returning this
We can also use this keyword to return the current class instance from the method.
To not duplicate the code, here’s a full practical example of how it’s implemented in the builder design pattern.
6. The this Keyword Within the Inner Class
We also use this to access the outer class instance from within the inner class:
Here, inside the constructor, we can get a reference to the KeywordTest instance with the KeywordTest.this call. We can go even deeper and access the instance variables like KeywordTest.this.name field.
7. Conclusion
In this article, we explored the this keyword in Java.
As usual, the complete code is available over on Github.
Slow MySQL query performance is all too common. Of course it is. A good way to go is, naturally, a dedicated profiler that actually understands the ins and outs of MySQL.
The Jet Profiler was built for MySQL only, so it can do things like real-time query performance, focus on most used tables or most frequent queries, quickly identify performance issues and basically help you optimize your queries.
Critically, it has very minimal impact on your server’s performance, with most of the profiling work done separately — so it needs no server changes, agents or separate services.
Basically, you install the desktop application, connect to your MySQL server, hit the record button, and you’ll have results within minutes:
Ключевое слово this
