this是什么？this的概念是什么？-优快云博客

本文详细探讨了Java中的关键字this，包括其概念、用法和常见场景。this用于引用当前对象的属性和方法，特别是在构造方法中进行重用和初始化。通过实例，解释了this如何指示当前正在调用类中方法的对象，并强调了使用this调用构造方法时的注意事项，如必须放在首行且需要有一个不使用this的构造方法作为出口。此外，还讨论了对象的内部访问权限，表明对象可以在内部直接访问私有成员。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

我们来说this这个关键字

我们先看this的概念

调用类中的属性 this.属性

调用类中的方法 this.方法()

调用类中的构造 this()

class Person3{
	private String name;
	private int age ;
	
	public Person3() {
	}
	
	public Person3(String name, int age) {
		this.name = name;
		this.age = age;
	}

	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
	
}
public class ThisDemo {
		public static void main(String[] args) {
			Person3 p = new Person3("MOHAN",19);
		System.out.println(p.getName()+"--->"+p.getAge());
		}
}

此代码输出结果：MOHAN--->19 此输出结果为正常结果

我们再来看下面代码

class Person3{
	private String name;
	private int age ;
	
	public Person3() {
	}
	
	public Person3(String name, int age) {
     //两处代码区别就在这个里
		name = name;
		age = age;
	}

	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
}
public class ThisDemo1{
		public static void main(String[] args) {
			Person3 p = new Person3("MOHAN",19);
		System.out.println(p.getName()+"--->"+p.getAge());
		}
}

此代码输出结果：null--->0

为什么是这样的结果呢？

我们来说一下我们可以说ThisDemo代码中

public Person3(String name, int age) {
        this.name = name;
        this.age = age;
    }

这个是有this的那我们来说this的作用翻译过来是‘这个’的意思

Person3 p = new Person3("MOHAN",19);

这时 name=“MOHAN” age=19; 赋给了this.name age赋给了 this.age

这个this指向了我们本类中的属性；然后通过实例化对象中赋值之后；

进行输出

System.out.println(p.getName()+"--->"+p.getAge());

就可以直接找到我们的值；

然后我们再看ThisDemo2中

public Person3(String name, int age) {
     //两处代码区别就在这个里
		name = name;
		age = age;
	}

好这时我们就可以看出来两个代码的区别。这个代码是没有this的

这时候我们来看我们

Person3 p = new Person3("MOHAN",19);

这个时候 name=“MOHAN” age=19; 赋给了name age赋给了age

虽然都是name 和 age 但是根据我们的就近原则；

这个时候我们来举个例子

我们来说如果我现在需要一根笔我的办公桌上有一根和我的家里有一根

我是不是要的办公桌上的，谁傻乎乎的去家里拿是吧！我们的this如果指向家里的那只有去家里拿了，这个就是this。

现在我们有一个程序

要求：在一个类中有三个构造方法，但是不管怎么样都要打印：“新的对象产生了”

class Person4{
	private String name;
	private int age ;
	
	public Person4() {
		System.out.println("新的对象产生了");
	}
	public Person4(String name) {
		System.out.println("新的对象产生了");
		this.name = name;
	}
	public Person4(String name, int age) {
		System.out.println("新的对象产生了");
		this.name = name;
		this.age = age;
	}

	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
}
public class ThisDemo03 {
		public static void main(String[] args) {
			Person4 p = new Person4("MOHAN",19);
		System.out.println(p.getName()+"--->"+p.getAge());
		}
}

输出结果为：

新的对象产生了

MOHAN--->19

但是问题来了我们每一个构造方法中都要写一个输出语句既不节省资源还不美观。

那么我们来用this()

class Person5{
	private String name;
	private int age ;
	
	public Person5() {
		System.out.println("新的对象产生了");
	}
	public Person5(String name) {
		this();
		this.name = name;
	}
	public Person5(String name, int age) {
		this(name);
		this.age = age;
	}

	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
}
public class ThisDemo5 {
		public static void main(String[] args) {
			Person5 p = new Person5("MOHAN",19);
		System.out.println(p.getName()+"--->"+p.getAge());
		}
}

输出结果为：

新的对象产生了

MOHAN--->19

我们可以看到输出结果是一样的代码简便美观了许多

提示：要知道我们的构造方法是对象操作前最早调用的，所以使用this调用构造方法的时候调用代码必须放在构造方法的首行，不然不但编译会报错，执行结果也一定会报错。

但是要注意：我们在使用this调用构造方法的时候必须要保证有一个构造方法是没有使用this()调用的，而此构造方法也会被作为调用的出口，一般这个出口都会使用无参构造来完成。如果都互相调用会进行死循环会报错！

以上是this使用最多的两种情况但是this有一个最终的概念----表示当前对象当前对象正在调用当前类中方法的对象，称为当前对象。

我们来看一下代码

class Person6{
	public void print(){
		System.out.println(this);
	}
}
public class ThisDemo6 {
		public static void main(String[] args) {
			Person6 p1 = new Person6();
			Person6 p2 = new Person6();
			p1.print();
			System.out.println(p1);
			p2.print();
			System.out.println(p2);
		}
}

输出结果：com.mohan.string.Person6@459189e1

com.mohan.string.Person6@459189e1

com.mohan.string.Person6@55f33675

有此结果可以得出之前的this属性就是代表当前对象的属性

class A{
	private B b = null;
	public void fun(){
		this.b= new B(this);
		this.b.fun();
	}
	public void print(){
		System.out.println("hello world");
	}
}
class B{
	private A a =null;
	public B(A a){
		this.a =a;
	}
	public void fun(){
		this.a.print();
	}
}
public class ThisDemo7 {
		public static void main(String[] args) {
			new A().fun();
		}
}

输出结果为：hello world

这个结果只是为了告诉我们A类的本方法，

接下来我们来说对象的比较

问？一个对象能不能在外部直接访问类中的私有成员

一个对象在类的内部能否访问私有成员呢？

class Person0{
	private String name;
	private int age ;
	
	public Person0() {
	}
	public Person0(String name, int age) {
		this.name= name;
		this.age = age;
	}
	
	public void fun(Person0 demp){
		demp.name ="mohan";
		demp.age = 20;
	}
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
}
public class CompareDemo01 {
		public static void main(String[] args) {
			Person0 p = new Person0("MOHAN",19);
			p.fun(p);
		System.out.println(p.getName()+"--->"+p.getAge());
		}
}

输出结果为：mohan--->20

我们可以看到输出的是我们方法中赋的值，这个就是说明一个对象在类的内部可以直接问访问私有成员。

以上代码只用于在类的比较中。

class Person02{
	private String name;
	private int age ;
	
	public Person02() {
	}
	public Person02(String name, int age) {
		this.name= name;
		this.age = age;
	}
	
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
}
public class CompareDemo02 {
		public static void main(String[] args) {
			Person0 p2 = new Person0("MOHAN",19);
			Person0 p1 = new Person0("MOHAN",19);
			if(p1.getName().equals(p2.getName())&&p1.getAge()==p2.getAge()){
				System.out.println("是同一个人");
			}
		}
}

输出结果：是同一个人

此时这个比较操作应该放在类的内部充当一个功能

就像这样

class Person03{
	private String name;
	private int age ;
	
	public Person03() {
	}
	public Person03(String name, int age) {
		this.name= name;
		this.age = age;
	}
	public boolean compaer(Person03 per){
		if(this==per){
			return true;
		}
		if(this.name.equals(per.name)&&this.age==per.age){
			return true;
		}else{
			return false;
		}
	}
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
}
public class CompareDemo03 {
		public static void main(String[] args) {
			Person03 p2 = new Person03("MOHAN",19);
			Person03 p1 = new Person03("MOHAN",19);
			if(p1.compaer(p1)){
				System.out.println("是同一个人");
			}
		}
}

输出结果：是同一个人

总结：this是在Java中比较难理解的一个关键字，我们在我们的代码中总是见到，

this属性就是代表当前对象的属性

使用this调用构造方法的时候必须要保证有一个构造方法是没有使用this()调用的

感谢收看！同时也欢迎各位大佬支出那里不好，新手上路~多多关照