{"id":5268,"date":"2021-03-23T16:28:30","date_gmt":"2021-03-23T16:28:30","guid":{"rendered":"https:\/\/ded9.com\/?p=5268"},"modified":"2026-02-18T11:47:56","modified_gmt":"2026-02-18T11:47:56","slug":"learn-this-keyword-in-java-in-simple-language","status":"publish","type":"post","link":"https:\/\/ded9.com\/de\/learn-this-keyword-in-java-in-simple-language\/","title":{"rendered":"Learn the \u201cthis\u201d Keyword in Java \u2014 Simple Explanation with Practical Examples"},"content":{"rendered":"

In this tutorial, you will learn the keyword this in Java<\/a>. An example will help you learn how and where to use it.<\/span><\/span><\/p>\n

This keyword<\/h2>\n

In Java, this refers to the current object in methods or constructs.\u00a0Let’s give an example to prove it.<\/p>\n

\n
    \n
  1. class MyClass {<\/li>\n
  2. int instVar;<\/li>\n
  3. MyClass (int instVar) {<\/li>\n
  4. this.instVar = instVar;<\/li>\n
  5. System.out.println (\u201cthis reference =\u201d + this);<\/li>\n
  6. }<\/li>\n
  7. public static void main (String [] args) {<\/li>\n
  8. MyClass obj = new MyClass (8);<\/li>\n
  9. System.out.println (\u201cobject reference =\u201d + obj);<\/li>\n
  10. }<\/li>\n
  11. }<\/li>\n<\/ol>\n<\/blockquote>\n

    Output<\/p>\n

    \n

    this reference = com.ThisAndThat.MyClass@74a14482<\/p>\n

    object reference = com.ThisAndThat.MyClass@74a14482<\/p>\n<\/blockquote>\n

    Note that the obj and this object identifiers are the same. This amounts to referring to the current object.<\/p>\n

    There are three situations in which this keyword is commonly used.<\/p>\n

    1. Use this to separate different variable sources<\/span><\/h3>\n

    In Java, you cannot define two or more variables with the same name in a domain (class domain or method domain). However, the sample variables and parameters may have the same name. As:<\/p>\n

    \n
    class MyClass {\r\n\r\nint instVar; \/\/ instVar instance variable\r\n\r\nMyClass (int instVar) {\/\/ instVar parameter\r\n\r\ninstVar = instVar;\r\n\r\n}\r\n\r\n}<\/pre>\n<\/div>\n
    The Java compiler is mistaken in the above program due to the ambiguous names. Therefore, to solve this problem, the keyword this is used.<\/p>\n
    Let’s look at an example without using this keyword:<\/p>\n
    \n
      \n
    1. class MyClass {<\/li>\n
    2. int instVar;<\/li>\n
    3. MyClass (int instVar) {<\/li>\n
    4. instVar = instVar;<\/li>\n
    5. }<\/li>\n
    6. public static void main (String [] args) {<\/li>\n
    7. MyClass mc = new MyClass (8);<\/li>\n
    8. System.out.println (\u201cmc.instVar =\u201d + mc.instVar);<\/li>\n
    9. }<\/li>\n
    10. }<\/li>\n<\/ol>\n<\/blockquote>\n
      Output<\/p>\n
      \n
      mc.instVar = 0<\/p>\n<\/blockquote>\n
      You might expect the output to be 8. Still, instead, it printed zero because the Java compiler made a mistake due to the name ambiguity between the sample variable and the constructor parameter.<\/p>\n
      Let’s rewrite the above code and use this keyword to solve this problem.<\/p>\n
      \n
        \n
      1. class MyClass {<\/li>\n
      2. int instVar;<\/li>\n
      3. MyClass (int instVar) {<\/li>\n
      4. this.instVar = instVar;<\/li>\n
      5. }<\/li>\n
      6. public static void main (String [] args) {<\/li>\n
      7. MyClass obj = new MyClass (8);<\/li>\n
      8. System.out.println (\u201cobj.instVar =\u201d + obj.instVar);<\/li>\n
      9. }<\/li>\n
      10. }<\/li>\n<\/ol>\n<\/blockquote>\n
        Output<\/p>\n
        \n
        mc.instVar = 8<\/p>\n<\/blockquote>\n
        You will now get the expected output. When you create an object, the Java compiler knows which object the constructor used.<\/p>\n
        When the Java compiler calls the constructor, the object that called the constructor replaces it inside the constructor.<\/p>\n
        Note: If you submit a parameter with a different name than the sample variables, the compiler will automatically attach this keyword.<\/p>\n
        This code:<\/p>\n
        \n
        class MyClass {\r\n\r\nint instVar;\r\n\r\nMyClass (int i) {\r\n\r\ninstVar = i;\r\n\r\n}\r\n\r\n}<\/pre>\n<\/div>\n
        It is equal to:<\/p>\n
        \n
        class MyClass {\r\n\r\nint instVar;\r\n\r\nMyClass (int i) {\r\n\r\nthis.instVar = i;\r\n\r\n}\r\n\r\n}<\/pre>\n<\/div>\n
        Another everyday use of this keyword is in a class’s getter and setter methods. For example:<\/p>\n
        \n
          \n
        1. class POJO {<\/li>\n
        2. String name;<\/li>\n
        3. void setName (String name) {<\/li>\n
        4. this.name = name;<\/li>\n
        5. }<\/li>\n
        6. String getName () {<\/li>\n
        7. return this.name;<\/li>\n
        8. }<\/li>\n
        9. public static void main (String [] args) {<\/li>\n
        10. POJO pojo = new POJO ();<\/li>\n
        11. pojo.setName (“Toshiba”);<\/li>\n
        12. System.out.println (“pojo.name:” + pojo.getName ());<\/li>\n
        13. }<\/li>\n
        14. }<\/li>\n<\/ol>\n<\/blockquote>\n
          Output<\/p>\n
          \n
          pojo.name: Toshiba<\/p>\n<\/blockquote>\n
          2- Using this in overloading manufacturers<\/h3>\n
          When working with builders, overloading, calling one builder over another, may be more useful. However, the creators cannot be explicitly identified. Therefore, you can use another form of this keyword to achieve this goal. (() this)<\/p>\n
          The pseudo-code<\/a> is shown here:<\/p>\n
          \n
          this (arg-list)<\/pre>\n<\/div>\n
          Here’s how to use this in the manufacturer’s call.<\/p>\n
          \n
            \n
          1. class Complex {<\/li>\n
          2. private int a, b;<\/li>\n
          3. \/\/ parameterize constructor<\/li>\n
          4. private Complex (int i, int j) {<\/li>\n
          5. this.a = i;<\/li>\n
          6. this.b = j;<\/li>\n
          7. }<\/li>\n
          8. private Complex (int i) {<\/li>\n
          9. this (i, i);\u00a0\/\/ invokes Complex (int i, int j);<\/li>\n
          10. }<\/li>\n
          11. private Complex () {<\/li>\n
          12. this (0);\u00a0\/\/ invokes Complex (int i);<\/li>\n
          13. }<\/li>\n
          14. @Override<\/li>\n
          15. public String toString () {<\/li>\n
          16. return this.a + \u201d+\u201d + this.b + \u201ci\u201d;<\/li>\n
          17. }<\/li>\n
          18. public static void main (String [] args) {<\/li>\n
          19. Complex c1 = new Complex (2, 3);<\/li>\n
          20. Complex c2 = new Complex (3);<\/li>\n
          21. Complex c3 = new Complex ();<\/li>\n
          22. System.out.println (c1);<\/li>\n
          23. System.out.println (c2);<\/li>\n
          24. System.out.println (c3);<\/li>\n
          25. }<\/li>\n
          26. }<\/li>\n<\/ol>\n<\/blockquote>\n
            Output<\/h4>\n
            \n
            2 + 3i<\/p>\n
            3 + 3i<\/p>\n
            0 + 0i<\/p>\n<\/blockquote>\n
            In the above program, it does not matter which constructor is called when introducing the object; finally, the parametric constructor is called.<\/p>\n
            Be careful when using this (). Constructors calling this () run slowly because calling an additional constructor adds another overhead. If your class is only used to create a handful of objects, using this () is useful. Another great advantage of using this () is reducing duplicate code.<\/p>\n
            3- Send this as an argument<\/h3>\n
            You can use this if you need to move the current object as an argument to a method.<\/p>\n
            \n
              \n
            1. class ThisExample {<\/li>\n
            2. int x;<\/li>\n
            3. int y;<\/li>\n
            4. ThisExample (int x, int y) {<\/li>\n
            5. this.x = x;<\/li>\n
            6. this.y = y;<\/li>\n
            7. System.out.println (\u201cBefore passing this to addTwo () method:\u201d);<\/li>\n
            8. System.out.println (\u201cx =\u201d + this.x + \u201c, y =\u201d + this.y);<\/li>\n
            9. addTwo (this);<\/li>\n
            10. System.out.println (\u201cAfter passing this to addTwo () method:\u201d);<\/li>\n
            11. System.out.println (\u201cx =\u201d + this.x + \u201c, y =\u201d + this.y);<\/li>\n
            12. }<\/li>\n
            13. void addTwo (ThisExample o) {<\/li>\n
            14. ox + = 2;<\/li>\n
            15. oy + = 2;<\/li>\n
            16. }<\/li>\n
            17. }<\/li>\n
            18. class Demo {<\/li>\n
            19. public static void main (String [] args) {<\/li>\n
            20. ThisExample obj = new ThisExample (1, -2);<\/li>\n
            21. }<\/li>\n
            22. }<\/li>\n<\/ol>\n<\/blockquote>\n
              Output<\/p>\n
              \n
              Before passing this to addTwo () method:<\/p>\n
              x = 1, y = -2<\/p>\n
              After passing this to addTwo () method:<\/p>\n
              x = 3, y = 0<\/p>\n<\/blockquote>\n
              Here, the addTwo () method is called with this as an argument from within the constructor.<\/p>\n
              FAQ<\/h2>\n
              \n
              \n
              \n
              What does the \u201cthis\u201d keyword mean in Java?<\/h3>\n
              \n\n
              It refers to the current object\u2014the instance whose method or constructor is being executed.<\/p>\n\n<\/div>\n<\/div>\n
              \n
              Why is the \u201cthis\u201d keyword used in Java?<\/h3>\n
              \n\n
              It\u2019s mainly used to differentiate instance variables from local variables and to access current object properties or methods.<\/p>\n\n<\/div>\n<\/div>\n
              \n
              Can \u201cthis\u201d be used to call constructors?<\/h3>\n
              \n\n
              Yes, using this() you can call another constructor within the same class to reuse initialization code.<\/p>\n\n<\/div>\n<\/div>\n<\/div>\n<\/div><\/div>\n","protected":false},"excerpt":{"rendered":"
              In this tutorial, you will learn the keyword this in Java. An example will help you learn how and where to use it. This keyword In Java, this refers to the current object in methods or constructs.\u00a0Let’s give an example to prove it. class MyClass { int instVar; MyClass (int instVar) { this.instVar = instVar; […]<\/p>\n","protected":false},"author":6,"featured_media":5269,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[11513],"tags":[840],"class_list":["post-5268","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-java-2","tag-java"],"acf":[],"amp_enabled":true,"_links":{"self":[{"href":"https:\/\/ded9.com\/de\/wp-json\/wp\/v2\/posts\/5268","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/ded9.com\/de\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/ded9.com\/de\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/ded9.com\/de\/wp-json\/wp\/v2\/users\/6"}],"replies":[{"embeddable":true,"href":"https:\/\/ded9.com\/de\/wp-json\/wp\/v2\/comments?post=5268"}],"version-history":[{"count":6,"href":"https:\/\/ded9.com\/de\/wp-json\/wp\/v2\/posts\/5268\/revisions"}],"predecessor-version":[{"id":266370,"href":"https:\/\/ded9.com\/de\/wp-json\/wp\/v2\/posts\/5268\/revisions\/266370"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/ded9.com\/de\/wp-json\/wp\/v2\/media\/5269"}],"wp:attachment":[{"href":"https:\/\/ded9.com\/de\/wp-json\/wp\/v2\/media?parent=5268"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/ded9.com\/de\/wp-json\/wp\/v2\/categories?post=5268"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/ded9.com\/de\/wp-json\/wp\/v2\/tags?post=5268"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}