java中this的用法?

发布网友 发布时间：2022-05-02 19:47

我来回答

共14个回答

懂视网 时间：2022-04-22 17:11

本篇文章给大家带来的内容是关于什么是this？一文让你秒懂this，有一定的参考价值，有需要的朋友可以参考一下，希望对你有所帮助。日常开发中经常会遇到 this 指向的 bug，郁闷好久才猛然醒悟，痛定思痛，将 this 做个汇总，以便在日后的开发工作中少走弯路。

注意：本文讲述只针对浏览器环境。

一：全局执行

console.log（this）；
// Window

可以看出在全局作用域中 this 指向当前的全局对象 Window。

二：函数中执行

1. 非严格模式中

function func （） {
console.log（this）；
}
func（）；
// Window

2. 严格模式中

"use strict";
function func （） {
console.log（this）；
}
func（）；
// undefined

三：作为对象的方法调用

当一个函数被当作一个对象的方法调用的时候，this 指向当前的对象 obj：

var obj = {
name: 'kk',
func: function （） {
console.log（this.name）；
}
}
obj.func（）；
// kk

如果把对象的方法赋值给一个变量，调用该方法时，this 指向 Window：

var obj = {
name: 'kk',
func: function （） {
console.log（this）；
}
}
var test = obj.func;
test（）；
// Window

四：作为一个构造函数使用

在 JS 中，为了实现类，我们需要定义一些构造函数，在调用一个构造函数的时候加上 new 这个关键字：

function Person （name） {
this.name = name;
console.log（this）；
}
var p1 = new Person（'kk'）；
// Person

此时，this 指向这个构造函数调用的时候实例化出来的对象。

当然了，构造函数其实也是一个函数，若将构造函数当做普通函数来调用，this 指向 Window:

function Person （name） {
this.name = name;
console.log（this）；
}
var p2 = Person（'MM'）；
// Window

五：在定时器中使用

setInterval（function （） {
console.log（this）；
}, 2000）
// Window
setTimeout（function （） {
console.log（this）；
}, 0）
// Window

如果没有特殊指向（指向更改请看下方：怎么改变 this 的指向），setInterval 和setTimeout 的回调函数中 this 的指向都是 Window 。这是因为 JS 的定时器方法是定义在 Window 下的。

六：箭头函数

在全局环境中调用：

var func = （） => {
console.log（this）；
}
func（）；
// Window

作为对象的一个函数调用：

var obj = {
name: 'hh',
func: function （） {
setTimeout（function （） {
console.log（this）；
}, 0）
}
}
obj.func（）；
// Window
var obj = {
name: 'hh',
func: function （） {
setTimeout（（） => {
console.log（this）；
}, 0）
}
}
obj.func（）；
// obj

不难发现，普通函数作为对象的一个函数被调用，this 指向 Window，箭头函数作为对象的一个函数被调用，this 指向定义时所在的对象，也就是 func 中的 this，即 obj。

箭头函数中 this 的值取决于该函数外部非箭头函数的 this 的值，且不能通过 call（） 、 apply（） 和 bind（） 方法来改变 this 的值。

七：call、apply、bind

call:

fun.call（thisArg[, arg1[, arg2[, …]]]）

它会立即执行函数，第一个参数是指定执行函数中 this 的上下文，后面的参数是执行函数需要传入的参数；

apply：

fun.apply（thisArg, [argsArray]）

它也会立即执行函数，第一个参数是指定执行函数中 this 的上下文，第二个参数是一个数组，是传给执行函数的参数（与 call 的区别）；

bind：

var foo = fun.bind（thisArg[, arg1[, arg2[, …]]]）；

它不会执行函数，而是返回一个新的函数，这个新的函数被指定了 this 的上下文，后面的参数是执行函数需要传入的参数；

我们来看个示例：

function Person（name, age） {
this.name = name;
this.age = age;
console.log（this）；
}
var obj = {
name: 'kk',
age: 6
};
Person.call（obj, 'mm', 10）；
// obj，{name: "mm", age: 10}
Person.apply（obj, ['mm', 10]）；
// obj，{name: "mm", age: 10}
var p1 = Person.bind（obj, 'mm', 10）
var p2 = new p1（）；
// Person {name: "mm", age: 10}

在这个示例中，call、apply 和 bind 的 this 都指向了 obj，都能正常运行；call、apply 会立即执行函数，call 和 apply 的区别就在于传递的参数，call 接收多个参数列表，apply 接收一个包含多个参数的数组；bind 不是立即执行函数，它返回一个函数，需要执行 p2 才能返回结果，bind 接收多个参数列表。

应用：怎么改变 this 的指向

为什么讲这个模块呢，为了便于大家更加透彻的理解上面所讲述的 this 指向问题，以及更加彻底的理解 JS 函数中重要的三种方法：call、apply、bind 的使用；并且在实际的项目开发中，我们经常会遇到需要改变 this 指向的情况。

我们来看下都有哪些方法：

1. 使用 es6 的箭头函数

var name = "hh";
var obj = {
name : "kk",
func1: function （） {
console.log（this.name）
},
func2: function （） {
setTimeout（function （） {
this.func1（）
}, 1000）；
}
};
obj.func2（）；
// Uncaught TypeError: this.func1 is not a function

这时会报错，因为 setTimeout 里函数的 this 指向 Window，而 Window 对象上是没有 func1 这个函数的。下面我们来修改成箭头函数：

var name = "hh";
var obj = {
name : "kk",
func1: function （） {
console.log（this.name）
},
func2: function （） {
setTimeout（（） => {
this.func1（）
}, 1000）；
}
};
obj.func2（）；
// kk

这时候，没有报错，因为箭头函数的 this 的值取决于该函数外部非箭头函数的 this 的值，也就是 func2 的 this 的值， 即 obj。

2. 在函数内部使用 _this = this

var name = "hh";
var obj = {
name : "kk",
func1: function （） {
console.log（this.name）
},
func2: function （） {
let _this = this;
setTimeout（function （） {
_this.func1（）
}, 1000）；
}
};
obj.func2（）；
// kk

此时，func2 也能正常运行。在 func2 中，首先设置 var _this = this，这里的 this 是指向 func2 的对象 obj，为了防止在 func2 中的 setTimeout 被 window 调用而导致的在 setTimeout 中的 this 为 window。我们将 this （指向变量 obj） 赋值给一个变量 _this，这样，在 func2 中我们使用 _this 就是指向对象 obj 了。

3. 使用 call、apply、bind

call：

var name = "hh";
var obj = {
name : "kk",
func1: function （） {
console.log（this.name）
},
func2: function （） {
setTimeout（function （） {
this.func1（）
}.call（obj）， 1000）；
}
};
obj.func2（）；
// kk

apply:

var name = "hh";
var obj = {
name : "kk",
func1: function （） {
console.log（this.name）
},
func2: function （） {
setTimeout（function （） {
this.func1（）
}.apply（obj）， 1000）；
}
};
obj.func2（）；
// kk
bind:
var name = "hh";
var obj = {
name : "kk",
func1: function （） {
console.log（this.name）
},
func2: function （） {
setTimeout（function （） {
this.func1（）
}.bind（obj）（）， 1000）；
}
};
obj.func2（）；
// kk

call、apply、bind 都能改变 this 的上下文对象，所以也没有报错，可以正常执行。

具体原因可看上述第七点，call、apply、bind。

4. new 实例化一个对象

如上：第四点，作为一个构造函数使用。

热心网友 时间：2022-04-22 14:19

Java关键字this只能用于方法方法体内。当一个对象创建后，Java虚拟机（JVM）就会给这个对象分配一个引用自身的指针，这个指针的名字就是 this。因此，this只能在类中的非静态方法中使用，静态方法和静态的代码块中绝对不能出现this，这在“Java关键字static、final 使用总结”一文中给出了明确解释。并且this只和特定的对象关联，而不和类关联，同一个类的不同对象有不同的this。

package test;
public class ThisTest {
private int i=0;
//第一个构造器：有一个int型形参
ThisTest(int i){
this.i=i+1;//此时this表示引用成员变量i，而非函数参数i
System.out.println("Int constructor i——this.i: "+i+"——"+this.i);
System.out.println("i-1:"+(i-1)+"this.i+1:"+(this.i+1));
//从两个输出结果充分证明了i和this.i是不一样的！
}
// 第二个构造器：有一个String型形参
ThisTest(String s){
System.out.println("String constructor: "+s);
}
// 第三个构造器：有一个int型形参和一个String型形参
ThisTest(int i,String s){
this(s);//this调用第二个构造器
//this(i);

this.i=i++;//this以引用该类的成员变量
System.out.println("Int constructor: "+i+"/n"+"String constructor: "+s);
}
public ThisTest increment(){
this.i++;
return this;//返回的是当前的对象，该对象属于（ThisTest）
}
public static void main(String[] args){
ThisTest tt0=new ThisTest(10);
ThisTest tt1=new ThisTest("ok");
ThisTest tt2=new ThisTest(20,"ok again!");

System.out.println(tt0.increment().increment().increment().i);
//tt0.increment()返回一个在tt0基础上i++的ThisTest对象，
//接着又返回在上面返回的对象基础上i++的ThisTest对象！
}
}
/*
细节问题注释已经写的比较清楚了，这里不在赘述，只是总结一下，其实this主要要三种用法：
1、表示对当前对象的引用！
2、表示用类的成员变量，而非函数参数，注意在函数参数和成员变量同名是进行区分！其实这是第一种用法的特例，比较常用，所以那出来强调一下。
3、用于在构造方法中引用满足指定参数类型的构造器（其实也就是构造方法）。但是这里必须非常注意：只能引用一个构造方法且必须位于开始！
还有就是注意：this不能用在static方法中！所以甚至有人给static方法的定义就是：没有this的方法！虽然夸张，但是却充分说明this不能在static方法中使用！
说明在什么情况下需要用到this：
第一、通过this调用另一个构造方法，用发是this(参数列表)，这个仅仅在类的构造方法中，别的地方不能这么用。
第二、函数参数或者函数中的局部变量和成员变量同名的情况下，成员变量被屏蔽，此时要访问成员变量则需要用“this.成员变量名”的方式来引用成员变量。当然，在没有同名的情况下，可以直接用成员变量的名字，而不用this，用了也不为错，呵呵。
第三、在函数中，需要引用该函所属类的当前对象时候，直接用this。
其实这些用法总结都是从对“this是指向对象本身的一个指针”这句话的更深入的理解而来的，死记不然容易忘记而且容易搞错，要理解！
*/

热心网友 时间：2022-04-22 15:37

一、指自己所在的对象。
比如在一个方法中，调用其他对象的变量或方法时，可以使用那个对象的对象名，比如aa.abc();
而调用自己所在对象的方法或变量时，不知道别人给起了什么名，所以直接用this.abc()就可以了。
二、看一个小例子中“this”的用法！

/**

* @author feng-neusoft

*

* 本示例为了说明this的三种用法！

*/

package test;

public class ThisTest {

private int i=0;

//第一个构造器：有一个int型形参

ThisTest(int i){

this.i=i+1;//此时this表示引用成员变量i，而非函数参数i

System.out.println("Int constructor i——this.i: "+i+"——"+this.i);

System.out.println("i-1:"+(i-1)+"this.i+1:"+(this.i+1));

//从两个输出结果充分证明了i和this.i是不一样的！

}

// 第二个构造器：有一个String型形参

ThisTest(String s){

System.out.println("String constructor: "+s);

}

// 第三个构造器：有一个int型形参和一个String型形参

ThisTest(int i,String s){

this(s);//this调用第二个构造器

//this(i);

/*此处不能用，因为其他任何方法都不能调用构造器，只有构造方法能调用他。

但是必须注意：就算是构造方法调用构造器，也必须为于其第一行，构造方法也只能调

用一个且仅一次构造器！*/

this.i=i++;//this以引用该类的成员变量

System.out.println("Int constructor: "+i+"/n"+"String constructor: "+s);

}

public ThisTest increment(){

this.i++;

return this;//返回的是当前的对象，该对象属于（ThisTest）

}

public static void main(String[] args){

ThisTest tt0=new ThisTest(10);

ThisTest tt1=new ThisTest("ok");

ThisTest tt2=new ThisTest(20,"ok again!");

System.out.println(tt0.increment().increment().increment().i);

//tt0.increment()返回一个在tt0基础上i++的ThisTest对象，

//接着又返回在上面返回的对象基础上i++的ThisTest对象！

}

}

运行结果：

Int constructor i——this.i: 10——11

String constructor: ok

String constructor: ok again!

Int constructor: 21

String constructor: ok again!

14

细节问题注释已经写的比较清楚了，总结一下，其实this主要要三种用法：

1、表示对当前对象的引用！

2、表示用类的成员变量，而非函数参数，注意在函数参数和成员变量同名是进行区分！其实这是第一种用法的特例，比较常用，所以那出来强调一下。

3、用于在构造方法中引用满足指定参数类型的构造器（其实也就是构造方法）。但是这里必须非常注意：只能引用一个构造方法且必须位于开始！

还有就是注意：this不能用在static方法中！所以甚至有人给static方法的定义就是：没有this的方法！虽然夸张，但是却充分说明this不能在static方法中使用！

热心网友 时间：2022-04-22 17:12

这个this肯定是用在某个类的方法里吧？呵呵，我们继续往下说。

举个例子：
public class persion{

private String name=null;
private int age;

public void setName(String name){
this.name=name;
}
public String getName(){

return name;
}

}

在这个类中setName方法中第一个变量用this是为了和本方法的参数this做区别，表示这个name指的是Person这个类的name属性，而不是name参数，如果去掉这个this，执行完这个方法后，Person类的name属性仍然为null
getName方法返回的Person类的name，之所以不用this是因为没有必要，因为编译器会知道这个name就指的是Person的name而不是其他的name（因为找个方法没有name变量和它混淆）。当然，这个方法你也可以显示的使用return this.name，没错。

热心网友 时间：2022-04-22 19:03

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!");
}
}

运行结果：

s = HelloWorld!
1 -> this.s = Hello
2 -> this.s = HelloWorld!

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

2. this作为参数传递
当你要把自己作为参数传递给别的对象时如：

public class A {
public A() {
new B(this).print();
}

public void print() {
System.out.println("Hello from A!");
}
}

public class B {
A a;
public B(A a) {
this.a = a;
}

public void print() {
a.print();
System.out.println("Hello from B!");
}
}

运行结果：
Hello from A!
Hello from B!

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

热心网友 时间：2022-04-22 23:36

this 确实麻烦。他表示的是当前对象，对象象你知道的就有很多拉，变量拉，线程等等。
上面那个例子不错，不过为了让你更清楚一点，有几点经验：

1.This用来表示全局变量，全局变量你应该知道(那你应该就知道楼上那段代码的答案了)；

2.看这里：
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();

}

}

我不知道你是否理解这段代码中showtest(this),这里的this就是把当前实例化 的 p传给了showtest方法，从而就运行了。。

我觉得懂了这2点就可以理解（最起码读懂）大部分的代码了！

热心网友 时间：2022-04-23 02:17

this 就是指本类所创建的对象，在参数与成员重名时用得比较多！也不知自己说的全不全，找本JAVA书翻翻应该都有介绍的！

class A{
private String a;

public void setA(String a)
{ this.a = a;
}
}

举个例子就是这个意思，A创建A的实例后，SET A的实例的成员a为传入参数。

热心网友 时间：2022-04-23 05:15

this表示当前对象！楼上的兄弟说错了~
看看这个
public class TestClass
{
int x,y;
void testShow(int x,int y){
this.x=x; //this.x 就是我们上 int x,y;中的X 。x是我们传来的x
this.y=y;
}

}

热心网友 时间：2022-04-23 08:30

this是指向当前对象的意思。在很多时候this可以省略，但很多时候this很重要，不可以省略！
比如一个类：
public test extends JFrame implements ActionListener{
public test(){
JButton button=new JButton("测试");
this.setVisable(true);
this.add(button);//这两处的this可以省！因为当前对象就是值的当前的test！所以写不写一样的！
button.addActionListener(this);//此处的就不能省！因为当前变量是button了而不再是test了。
//需要意会的，说也不能说得太明白，我用例子，希望你能理解下！另外，此代码不完整！只自
//己随便写的！
}
}

热心网友 时间：2022-04-23 12:01

this常用方法很有几个；我原来资料上找的；
1、我们想通过构造方法将外部传入的参数赋值给类的成员变量，构造方法的形式参数名称与类的成员变量名相同。例如：
class Person
{
String name;
public Person(String name)
{
this.name = name;
}
}2、假设有一个容器类和一个部件类，在容器类的某个方法中要创建部件类的实例对象，而部件类的构造方法要接受一个代表其所在容器的参数。例如：
class Container
{
Component comp;
public void addComponent()
{
comp = new Component(this);
}
}
class Component
{
Container myContainer;
public Component(Container c)
{
myContainer = c;
}
}
3、构造方法是在产生对象时被java系统自动调用的，我们不能再程序中像调用其他方法一样去调用构造方法。但我们可以在一个构造方法里调用其他重载的构造方法，不是用构造方法名，而是用this（参数列表）的形式，根据其中的参数列表，选择相应的构造方法。例如
public class Person
{
String name;
int age;
public Person(String name)
{
this.name = name;
}
public Person(String name,int age)
{
this(name);
this.age = age;
}
}

1.this可指代对象自己本身： 当在一个类中要明确指出使用对象自己的属性或方法时就应该加上this引用，如下例 子：

输出的结果为： Maybe=love you

this.Maybe=love

this.Maybe=love you

第一行直接对构造函数中传递过来的参数Maybe进行输出，第二行是对成员变量(属性） Maybe的输出，第三行是先对成员变量（属性）Maybe赋值后进行输出。

2.在一个构造函数中调用另一个构造函数时，用this关键字:
例如
public class Flower{

private int petalCount=0;

private String s=new String("null");

public Flower(int petals){

petalCount=petals;

}

public Flower(String ss){

s=ss;

}

public Flower(String s,int petals){

this(petals); //java中在一个构造函数中可以调用一次其他的构造函数，并且这条语句 必须在这个构造函数的第一行

this.s=s;

}

}

public class love{

String Maybe="love";

public love(String Maybe){

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

System.out.println("this.Maybe="+this.Maybe);

this.Maybe=Maybe;

System.out.println("this.Maybe="+this.Maybe);

}

public static void main(String[] args){

love s=new love("love you");
}
}

最先没看懂以为是this一些用法，
这样就可以了：

public class A{
static char a='A';
class B{
char a='B';
public void m1(char a){
A.a=a;

如何把参数a的值赋给A类中的a；
}
}
}
指明对象

热心网友 时间：2022-04-23 15:49

主要是用于调用类中自己的属性或方法，用法就是this.后边跟属性或方法就可以了

热心网友 时间：2022-04-23 19:54

java中this有两种用法：
1、代表当前类
public class Dog{
private String name;
private float age;
public setName(String name){
this.name = name;
}
.......
}
这里的this就代表的当前的这个Dog类。this.name可以理解为dog.name，只是理解，不是等于。
2、在构造函数中的使用
public class Dog{
private String name;
private int age;
//有一个参数的构造函数
public Dog(String name){
this.name = name;
}
public Dog(String name,int age){
this.name = name;
this.age = age;
}
//这个无参构造方法里调用的有两个参数的构造方法，这个也就是this的第二种用法了！
public Dog(){
this("nihao",20);
}
}

热心网友 时间：2022-04-24 00:15

其实在现实的编程中，this并不经常用，this表示当前类，可以用this调用本类的方法，也可以调用属性。。

热心网友 时间：2022-04-24 04:53

离自己比较近的。