this关键字在JAVA和JS中的异同

this在JS中的用法

由于js中this 是在运行期进行绑定的，所以js中的 this 可以是全局对象、当前对象或者任意对象，这完全取决于函数的调用方式。JavaScript 中函数的调用有以下几种方式怎么区别：

1.this关键字在何处出现？

　　this他只能出现在函数中。当然在全局作用域中是个例外，意思是this只可能在两种情境下出现，一个是在函数体内，另一个是在全局作用域。

2.this是什么？

　　this是关键字，语言规范里规定他指向函数执行时的当前对象。它代表函数运行时，自动生成的一个内部对象，只能在函数内部使用。

3.this到底指向哪？

　　首先明确this在JavaScript中和函数的执行环境而不是声明环境相关。

　　第一条中已经说过，this只能出现在函数中和全局作用域中，全局作用域中this指向全局对象（全局对象在浏览器这个环境中指window）。

　　如果this出现在函数中，那就要分情况来看this到底指向哪了。指向的依据就是函数的执行环境而不是声明环境。其实可以以一句话来概括就是this永远指向所在函数的所有者，当没有显示的所有者的时候，那么this指向全局对象。

4.各种情况下的this的具体指向？

　　　（1）.全局的作用域

　　　　 1 console.log(this)

　　　　window调用所有，this指向window

注：（js变量作用域可分为："全局变量"和"局部变量"。"全局变量"：申明在函数之外的变量，"局部变量"：申明在函数体中的变量，并且只能在当前函数体内访问，如：function(){var a = 0;}在申明变量是凡是没有var关键字，而直接赋值的变量均为全局变量）　　

　　　（2）.函数作为某个对象的成员方法调用

+

　　在全局作用域中声明全局变量name，在obj对象中声明同时也声明一个name。当用对象obj调用他的成员方法fn的时候，this指向这个obj，因此打印出来的this.name为obj的name。

　　所以函数作为某个对象的成员方法调用时this指向该对象。

　　(3).函数作为函数直接使用

　　同样的还是上边的一段代码，只不过这次我们把fn这个函数直接执行，这时在函数执行的时候他没有明确的当前对象，所以默认这时this就指向了全局对象。

　　所以函数作为函数直接使用时this指向全局对象。

　　（4）.函数作为构造函数调用

var name = 'a';
function Obj () {
    this.name = 'b';
}
Obj.prototype.getName = function () {
    console.log(this.name);
}
var myObj = new Obj();
myObj.getName();//b

　　函数作为构造函数调用时this指向用该构造函数构造出来的新对象。

　　（5）.setTimeout（延迟）和setInterval（持续）以及匿名函数(函数调用模式就是指向window)

 1 var name = "a";
 2 var obj = {
 3     name: "b",
 4     getName: function () {
 5         setTimeout(function () {
 6             console.log(this.name);
 7         }, 1000);
 8     },
 9 };
10
11 obj.getName();//a

　　　　这两个函数执行的时候第一个参数可以为一个匿名函数，也可以是一个声明好的函数引用，所以this指向也就是指这个匿名函数或者函数引用的this的指向。通过第一条已经知道匿名函数或者在全局作用域中声明的函数直接执行的时候，其中的this指向全局对　 象，所以在这里也一样，setTimeout和setInterval两者运行时，this指向全局对象。

　　这个时候如果还想输出的是b，也就是this指向obj的话就需要做点手脚了。

 1 var name = "a";
 2 var obj = {
 3     name: "b",
 4     getName: function () {
 5         var that = this;
 6         setTimeout(function () {
 7             console.log(that.name);
 8         }, 1000);
 9     },
10 };
11
12 obj.getName();//b

　　当然这样是改变不了this指向的，但是可以通过把this赋值给that，就实现了保存this指向的作用。

　　紧接着是匿名函数。

　　 1 (function () { 2 console.log(this); 3 })()//window

　　匿名函数中的this指向全局对象，因为他没有显示的所有者。

（6）apply、call、bind

　　这三个函数是函数对象的一个方法，他们的作用就是为了改变函数执行时候的this指向，具体用法如下：

　　call：call(obj[,arg1][,arg2]);第一个参数为强制改变需要指向的对象，后边可选的是该函数的参数，如果不传obj的话默认为window。

　　apply:apply(obj[,arr]);第一个参数为强制改变需要指向的对象，后边可选的是该参数集合的数组形式，如果不传obj的话默认为window。

　　apply和call的作用和调用形式基本一致，不同的是call后面的参数与方法中是一一对应的，而apply的第二个参数是一个数组，数组中的元素是和方法中一一对应的，这就是两者最大的区别。两者都可以不传参数，此时默认改变指向的对象为全局对象。

　　bind:bind的调用形式和call相同，但是他返回的是改变调用对象后的函数引用，所以还要再执行一次，也就是obj.fun().bind()()。

总结:1.作为函数调用的时候，this指向全局对象（window）。

　　 2.作为对象的方法调用，this指向调用的对象（谁调用指向谁）。

　　 3.作为构造函数被调用的this指向新的对象（指向new出来的对象）。

　　 4.apply，call方法调用指向这些方法的第一个参数。

this在Java中的用法（结合实例）

this.属性名

大部分时候，普通方法访问其他方法、成员变量时无须使用 this 前缀，但如果方法里有个局部变量和成员变量同名，但程序又需要在该方法里访问这个被覆盖的成员变量，则必须使用 this 前缀。

例 1

假设有一个教师类 Teacher 的定义如下：

1. public class Teacher {
2. private String name; // 教师名称
3. private double salary; // 工资
4. private int age; // 年龄
5. }

在上述代码中 name、salary 和 age 的作用域是 private，因此在类外部无法对它们的值进行设置。为了解决这个问题，可以为 Teacher 类添加一个构造方法，然后在构造方法中传递参数进行修改。代码如下：

1. // 创建构造方法，为上面的3个属性赋初始值
2. public Teacher(String name,double salary,int age) {
3. this.name = name; // 设置教师名称
4. this.salary = salary; // 设置教师工资
5. this.age = age; // 设置教师年龄
6. }

在 Teacher 类的构造方法中使用了 this 关键字对属性 name、salary 和 age 赋值，this 表示当前对象。this.name=name语句表示一个赋值语句，等号左边的 this.name 是指当前对象具有的变量 name，等号右边的 name 表示参数传递过来的数值。

创建一个 main() 方法对 Teacher 类进行测试，代码如下：

1. public static void main(String[] args) {
2. Teacher teacher = new Teacher("王刚",5000.0,45);
3. System.out.println("教师信息如下：");
4. System.out.println("教师名称："+teacher.name+"\n教师工资："+teacher.salary+"\n教师年龄："+teacher.age);
5. }

运行该程序，输出的结果如下所示。

教师信息如下：
教师名称：王刚
教师工资：5000.0
教师年龄：45

提示：当一个类的属性（成员变量）名与访问该属性的方法参数名相同时，则需要使用 this 关键字来访问类中的属性，以区分类的属性和方法中的参数。

this.方法名

this 关键字最大的作用就是让类中一个方法，访问该类里的另一个方法或实例变量。

例 2

假设定义了一个 Dog 类，这个 Dog 对象的 run( ) 方法需要调用它的 jump( ) 方法，Dog 类的代码如下所示：

1. /**
2. * 第一种定义Dog类方法
3. **/
4. public class Dog {
5. // 定义一个jump()方法
6. public void jump() {
7. System.out.println("正在执行jump方法");
8. }
9. // 定义一个run()方法，run()方法需要借助jump()方法
10. public void run() {
11. Dog d = new Dog();
12. d.jump();
13. System.out.println("正在执行 run 方法");
14. }
15. }

使用这种方式来定义这个 Dog 类，确实可以实现在 run( ) 方法中调用 jump( ) 方法。下面再提供一个程序来创建 Dog 对象，并调用该对象的 run( ) 方法。

1. public class DogTest {
2. public static void main(String[] args) {
3. // 创建Dog对象
4. Dog dog = new Dog();
5. // 调用Dog对象的run()方法
6. dog.run();
7. }
8. }

在上面的程序中，一共产生了两个 Dog 对象，在 Dog 类的 run( ) 方法中，程序创建了一个 Dog 对象，并使用名为 d 的引用变量来指向该 Dog 对象。在 DogTest 的 main() 方法中，程序再次创建了一个 Dog 对象，并使用名为 dog 的引用变量来指向该 Dog 对象。

下面我们思考两个问题。

1）在 run( ) 方法中调用 jump( ) 方法时是否一定需要一个 Dog 对象？

答案是肯定的，因为没有使用 static 修饰的成员变量和方法都必须使用对象来调用。

2）是否一定需要重新创建一个 Dog 对象？

不一定，因为当程序调用 run( ) 方法时，一定会提供一个 Dog 对象，这样就可以直接使用这个已经存在的 Dog 对象，而无须重新创建新的 Dog 对象了。因此需要在 run() 方法中获得调用该方法的对象，通过 this 关键字就可以满足这个要求。

this 可以代表任何对象，当 this 出现在某个方法体中时，它所代表的对象是不确定的，但它的类型是确定的，它所代表的只能是当前类的实例。只有当这个方法被调用时，它所代表的对象才被确定下来，谁在调用这个方法，this 就代表谁。

将前面的 Dog 类的 run( ) 方法改为如下形式会更加合适，run( ) 方法代码修改如下，其它代码不变。

1. /**
2. * 第二种定义Dog类方法
3. **/
4. // 定义一个run()方法，run()方法需要借助jump()方法
5. public void run() {
6. // 使用this引用调用run()方法的对象
7. this.jump();
8. System.out.println("正在执行run方法");
9. }

从第一种 Dog 类定义来看，在 Dog 对象的 run( ) 方法内重新创建了一个新的 Dog 对象，并调用它的 jump( ) 方法，这意味着一个 Dog 对象的 run( ) 方法需要依赖于另一个 Dog 对象的 jump( ) 方法，这不符合逻辑。

第二种 Dog 类定义是当一个 Dog 对象调用 run( ) 方法时，run( ) 方法需要依赖它自己的 jump( ) 方法，与第一种定义类的方法相比，更符合实际情形。

在现实世界里，对象的一个方法依赖于另一个方法的情形很常见，例如，吃饭方法依赖于拿筷子方法，写程序方法依赖于敲键盘方法。这种依赖都是同一个对象两个方法之间的依赖。因此，Java 允许对象的一个成员直接调用另一个成员，可以省略 this 前缀。也就是说，将上面的 run( ) 方法改为如下形式也完全正确。

1. public void run() {
2. jump();
3. System.out.println("正在执行run方法");
4. }

大部分时候，一个方法访问该类中定义的其他方法、成员变量时加不加 this 前缀的效果是完全一样的。

注意：对于 static 修饰的方法而言，可以使用类来直接调用该方法，如果在 static 修饰的方法中使用 this 关键字，则这个关键字就无法指向合适的对象。所以，static 修饰的方法中不能使用 this 引用。并且 Java 语法规定，静态成员不能直接访问非静态成员。

省略 this 前缀只是一种假象，虽然程序员省略了调用 jump() 方法之前的 this，但实际上这个 this 依然是存在的。

this( )访问构造方法

this( ) 用来访问本类的构造方法（构造方法是类的一种特殊方法，方法名称和类名相同，没有返回值。详细了解可参考《Java构造方法》一节），括号中可以有参数，如果有参数就是调用指定的有参构造方法。

例 3

下面定义一个 Student 类，使用 this( ) 调用构造方法给 name 赋值，Student 类的代码如下所示：

1. public class Student {
2. String name;
3. // 无参构造方法（没有参数的构造方法）
4. public Student() {
5. this("张三");
6. }
7. // 有参构造方法
8. public Student(String name) {
9. this.name = name;
10. }
11. // 输出name和age
12. public void print() {
13. System.out.println("姓名：" + name);
14. }
15. public static void main(String[] args) {
16. Student stu = new Student();
17. stu.print();
18. }
19. }

输出结果为：

姓名：张三

注意：

• this( ) 不能在普通方法中使用，只能写在构造方法中。
• this关键字必须放在非静态方法里（原因：static方法就是没有this的方法。在static方法内部不能调用非静态方法，反过来是可以的。而且可以在没有创建任何对象的前提下，仅仅通过类本身来调用static方法。这实际上正是static方法的主要用途。）

• 在构造方法中使用时，必须是第一条语句。