这个this关键字到底是指什么东西,什么时候可以用,什么时候不用,我看书上说有时候还可以省略.再就是经常看到什么this.name=name,我去,名字等于名字,看到就蒙蔽了?this到底怎么用啊

this就是指调用他的方法所归属的类，个人理解。

this关键字是在方法重名的时候用,一般只是在面试的时候会提到,在开发的时候是不会出现的.
还有this是在方法下的,谁来调用我所在的方法下,我就代表谁.你所说的是在有参构造下.

public Student () {} // 空参
public Student(String name, int age){    //有参
    this.name = name;
    this.age =age;
}
比如上面说的,那谁来调用有参,this就代表谁 !希望对你哟帮助!!!

谁来调用有参,this就代表谁

java中this一般有两种用法，一种用法是代表当前类，常见的就是this.name=name，表示当前类的名字默认为就是这个name了，具体怎么说呢，这得调用的时候你就清楚了。第二种就是在构造函数中使用，在构造函数中使用一个到两个参数，然后调用this，具体的有很多书籍和百度都可以参考。一般来说比较简单，也容易理解。你可以自己先看看，不理解再问

java中this一般有两种用法，一种用法是代表当前类，常见的就是this.name=name，表示当前类的名字默认为就是这个name了，具体怎么说呢，这得调用的时候你就清楚了。第二种就是在构造函数中使用，在构造函数中使用一个到两个参数，然后调用this，具体的有很多书籍和百度都可以参考。一般来说比较简单，也容易理解。你可以自己先看看，不理解再问

this一般最多用在javabean中的getter和setter方法中，用来区分名字一样的成员变量和形式参数的。还有就是在本类中调用本类的构造方法和一般方法是
也可以用this.来表明，怕的是重写的父类方法冲突了。

this一般代表当前对象。
从自己某个类的另一个方法内部调用一个类方法，就不必使用this，只需直接调用那个方法
即可。
有时候类中成员函数自变量的名字以及类成员数据 的名字是相同的，为了避免混淆，可以用this来引用成员数据。

this.name = name
举个例子：
//定义一个Person类
class Person{
     //成员变量
     private String name;
    //成员方法
     public void setName(String name){
         this.name = name;
       //****请注意，这里等式    右边是指成员方法setName(name)中的 name;  左边是指成员变量中的 name；this代表当前对象对成员变量的调用。
      //****换种思考，若无this, name = name; 我们会弄不清name 的值究竟付给自己本身还是付给谁。
      }
}

希望对你有帮助

从继承的角度理解，this与super是相对的，一般在有继承状态出现的时候出现。this表示调用本类的方法或变量，而super是调用父类的

this是用来区分成员变量和局部变量重名的,当给成员变量中的 name赋值的话,java中根据就近原则,只会赋值给局部变量name赋值,而不会赋值给成员变量name,this.中记录的是主方法中创建的对象的值 ,this.name就是主方法中被创建的对象.

this关键字主要作用有 1，可以明确地去访问一个类的成员变量，解决与局部变量名称冲突问题；
2，通过This关键字调用成员方法；
3，构造方法是在实例化对象时被Java虚拟机自动调用的，在程序中不能像调用其它方法一样去调用构造方法，但可以在一个构造方法中使用this([参数1，参数2......])的形式调用其它构造方法；
还有在继承中可以调用父类的构造方法

首先明白:成员变量用对象 .  来调用。也就是this. age调用成员变量age。
               局部变量是方法里，方法体上的变量。
先实例一个类对象 Person p1 =new Person();
下面p1调用setName 方法  p1.setAge(18)；

1. class Person{
   
2.       private String name;
   
3.       private int age;
   
4.       public void setAge (int age){
   
5.              this.age = age;//右边的age就是setAge里的参数（int age）,左边的this代表对象，也就是最上面的p1，也就是说p1调用setAge方法，this.age就是p1将自己的成员变量age赋值;  这样就把成员变量的age(就是private int age)与局部变量（setAge里的age,也就是等号右边的age）区分开来了。如果局部变量里的不是int age ,而是int a，就不需要用this来调用了.例如下面的代码2
   
6. 
   
7.       }
   
8. }

复制代码

代码2：

1. class Person {
   
2.       private int age;
   
3.       public void setAge (int a) {
   
4.              age = a;//这里的局部变量为a，与成员变量age不重名了，不需要区分成员变量与局部变量，所以不用this来代表当前对象（p1）的引用了。
   
5.       }
   
6. 
   
7. }

复制代码

说到底就是怕你如果写成这样
pubilc void setAge (int age) {
       age = age;//这么写俩age都是局部变量的了，所以无法赋值给成员变量上的age（就是private int age里的age）,所以就用个this来代表当前对象（p1）的引用。成员变量用对象 .  来调用。也就是this. age调用成员变量age。
｝这已经是我写过的最详细的解释了，希望楼主给分奖励。不明白可以继续问的。

用于构造方法中的,代表所指向有参构造的变量,方法

可以把this理解为一个未知数x，而创建一个在这个x类中的对象，就是给这个x赋值。
而这个this就可以理解为这个对象的替身。
最好形成自己的理解逻辑。这样才能学好java

等你自己理解这个this的作用，之后就可以看看书上讲的，怎么用Java的官方语言去形容它。

表示当前这个类的实例对象的name

this表示的是当前调用对象，哪个对象用到这个方法，this就表示哪个对象

1.     当成员变量和局部变量重名时，在方法中使用this时，表示的是该方法所在类中的成员变量。（this是当前对象自己）

如：public class Hello {

    String s = "Hello";



    public Hello(String s) {

       System.out.println("s = " + s);

       System.out.println("1 -> this.s = " + this.s);

       this.s = s;//把参数值赋给成员变量，成员变量的值改变

       System.out.println("2 -> this.s = " + this.s);

    }



    public static void main(String[] args) {

       Hello x = new Hello("HelloWorld!");

       System.out.println("s=" + x.s);//验证成员变量值的改变

    }

}

结果为：s = HelloWorld!

1 -> this.s = Hello

2 -> this.s = HelloWorld!

s=HelloWorld!

在这个例子中，构造函数Hello中，参数s与类Hello的成员变量s同名，这时如果直接对s进行操作则是对参数s进行操作。若要对类Hello的成员变量s进行操作就应该用this进行引用。运行结果的第一行就是直接对构造函数中传递过来的参数s进行打印结果； 第二行是对成员变量s的打印；第三行是先对成员变量s赋传过来的参数s值后再打印，所以结果是HelloWorld!而第四行是主函数中直接打印类中的成员变量的值，也可以验证成员变量值的改变。

2．把自己当作参数传递时，也可以用this.(this作当前参数进行传递)

      class A {

    public A() {

       new B(this).print();// 调用B的方法

    }

    public void print() {

       System.out.println("HelloAA from A!");

    }

}

class B {

    A a;

    public B(A a) {

       this.a = a;

    }

    public void print() {

       a.print();//调用A的方法

       System.out.println("HelloAB from B!");

    }

}

public class HelloA {

    public static void main(String[] args) {

       A aaa = new A();

       aaa.print();

       B bbb = new B(aaa);

       bbb.print();

    }

}

结果为：HelloAA from A!

HelloAB from B!

HelloAA from A!

HelloAA from A!

HelloAB from B!

在这个例子中，对象A的构造函数中，用new B(this)把对象A自己作为参数传递给了对象B的构造函数。

3．         有时候，我们会用到一些内部类和匿名类，如事件处理。当在匿名类中用this时，这个this则指的是匿名类或内部类本身。这时如果我们要使用外部类的方法和变量的话，则应该加上外部类的类名。如：

    public class HelloB {

    int i = 1;



    public HelloB() {

       Thread thread = new Thread() {

           public void run() {

              for (int j=0;j<20;j++) {

                  HelloB.this.run();//调用外部类的方法

                  try {

                     sleep(1000);

                  } catch (InterruptedException ie) {

                  }

              }

           }

       }; // 注意这里有分号

       thread.start();

    }



    public void run() {

       System.out.println("i = " + i);

       i++;

    }

   

    public static void main(String[] args) throws Exception {

       new HelloB();

    }

}

在上面这个例子中, thread 是一个匿名类对象，在它的定义中，它的 run 函数里用到了外部类的 run 函数。这时由于函数同名，直接调用就不行了。这时有两种办法，一种就是把外部的 run 函数换一个名字，但这种办法对于一个开发到中途的应用来说是不可取的。那么就可以用这个例子中的办法用外部类的类名加上 this 引用来说明要调用的是外部类的方法 run。

4．    在构造函数中，通过this可以调用同一类中别的构造函数。如：

        public class ThisTest {

    ThisTest(String str) {

       System.out.println(str);

    }

    ThisTest() {

       this("this测试成功！");

    }



    public static void main(String[] args) {

       ThisTest thistest = new ThisTest();

    }

}

   

为了更确切的说明this用法，另外一个例子为：

public class ThisTest {

    private int age;

    private String str;



    ThisTest(String str) {

       this.str=str;

       System.out.println(str);

    }

    ThisTest(String str,int age) {

       this(str);

       this.age=age;

       System.out.println(age);

    }



    public static void main(String[] args) {

       ThisTest thistest = new ThisTest("this测试成功",25);

      

    }

}

        结果为：this测试成功

25

         

值得注意的是：
1：在构造调用另一个构造函数，调用动作必须置于最起始的位置。
2：不能在构造函数以外的任何函数内调用构造函数。
3：在一个构造函数内只能调用一个构造函数。

5．this同时传递多个参数。

public class TestClass {

    int x;

    int y;



    static void showtest(TestClass tc) {//实例化对象

       System.out.println(tc.x + " " + tc.y);

    }

    void seeit() {

       showtest(this);

    }



    public static void main(String[] args) {

       TestClass p = new TestClass();

       p.x = 9;

       p.y = 10;

       p.seeit();

    }

}

结果为：9 10

代码中的showtest(this),这里的this就是把当前实例化的p传给了showtest（）方法，从而就运行了。