JAVA自学教程之（关键字一this）



JAVA自学教程之（关键字一this）。关键字：
this 关键字
this 使用一：

直接以代码解释：

 

  1. class Man
  2. {
  3.     private int age;
  4.     private String name;
  5.     Man()
  6.     {
  7.         name= null;age = 0;
  8.     }
  9.     Man(String n)//正常直接打印”BLF,0″,但是把n改为name呢，就会打印null，0
  10.     {   name = n;  }//改成name虽然增加了阅读性，但是参数名进栈时，栈区已经有了一个局部变量名name，
  11.                               那么name的赋值，只会把自己赋值给自己。如同int x = 5； x = x；
  12.     /*
  13.     Man(String name)
  14.     {
  15.         this.name = name;//this关键字的作用就是说，这个对象的name，那么会进堆内存，就不会起冲突了
  16.     }
  17.     */
  18.     Man(int a)
  19.     { age = a; }
  20.     Man(int a,String n)
  21.     {
  22.         age = a;
  23.         name = n;
  24.     }
  25.     void run()
  26.     {
  27.         System.out.println(name+”,”+age);//实际上这里省略了this.name+”,”+this.age
  28.     }
  29. }
  30. public class Main
  31. {
  32.     public static void main (String[] args)
  33.     {
  34.         Man jo = new Man(“BLF”);
  35.         jo.run();
  36.     }
  37. }
class Man
{
	private int age;
	private String name;
	Man()
	{
		name= null;age = 0;
	}
	Man(String n)//正常直接打印"BLF,0",但是把n改为name呢，就会打印null，0
	{	name = n;  }//改成name虽然增加了阅读性，但是参数名进栈时，栈区已经有了一个局部变量名name，
                              那么name的赋值，只会把自己赋值给自己。如同int x = 5； x = x；
 	/*
	Man(String name)
	{
		this.name = name;//this关键字的作用就是说，这个对象的name，那么会进堆内存，就不会起冲突了
	} 
	*/
	Man(int a)
	{ age = a; }
	Man(int a,String n)
	{
		age = a;
		name = n;
	}
	void run()
	{
		System.out.println(name+","+age);//实际上这里省略了this.name+","+this.age
	}
}
public class Main 
{	
	public static void main (String[] args) 
	{
		Man jo = new Man("BLF");
		jo.run();
	}
}

所以：当局部变量和成员变量重名时，可以用关键字this来区分，this就代表当前对象（this就是所在函数所属对象的引用）： this代表（构造函数）Man所属的对象jo。哪个对象调用了this所在的函数，那么this就代表那个对象。
PS:只有对象才能调用构造函数 所以，正规且阅读性强的代码

  1. class Man
  2. {
  3.     private int age;
  4.     private String name;
  5.     Man()
  6.     {
  7.         name= null;age = 0;
  8.     }
  9.     Man(String name)
  10.     {   this.name = name;  }
  11.     Man(int age)
  12.     { this.age = age; }
  13.     Man(int age,String name)
  14.     {
  15.         this.age = age;
  16.         this.name = name;
  17.     }
  18.     void run()
  19.     {
  20.         System.out.println(this.name+”,”+this.age);
  21.     }
  22. }
  23. public class Main
  24. {
  25.     public static void main (String[] args)
  26.     {
  27.         Man jo = new Man(“BLF”);
  28.         jo.run();
  29.     }
  30. }
class Man
{
	private int age;
	private String name;
	Man()
	{
		name= null;age = 0;
	}
	Man(String name)
	{	this.name = name;  }
	Man(int age)
	{ this.age = age; }
	Man(int age,String name)
	{
		this.age = age;
		this.name = name;
	}
	void run()
	{
		System.out.println(this.name+","+this.age);
	}
}
public class Main 
{	
	public static void main (String[] args) 
	{
		Man jo = new Man("BLF");
		jo.run();
	}
}

以内存分配图解释this

 


this 使用二： this可以在构造函数里调用其他构造函数
错误演示：

 

  1. class Man
  2. {
  3.     private int age;
  4.     private String name;
  5.     Man()
  6.     {
  7.         name= null;
  8.         age = 0;
  9.     }
  10.     Man(String name)
  11.     {   this.name = name;
  13.     }
  14.     Man(int age)
  15.     {
  16.         this.age = age;
  18.     }
  19.     Man(int age,String name)
  20.     {
  21.         //上面已经写过了，是不是就可以进行调用了呢？答案是否定的
  22.         this.Man(name);//this代表了对象，对象要想进行是使用必须先初始化，但是
  23.         this.Man(age);//这里还没有进行初始化，就开始使用，所以是错误的
  25.     }
  26.     void run()
  27.     {
  28.         System.out.println(this.name+”,”+this.age);
  29.     }
  30. }
  31. public class Main
  32. {
  33.     public static void main (String[] args)
  34.     {
  35.         Man jo = new Man(12,”BLF”);//此处传2个参数
  36.         jo.run();
  37.     }
  38. }
class Man
{
	private int age;
	private String name;
	Man()
	{
		name= null;
		age = 0;
	}
	Man(String name)
	{	this.name = name; 

	}
	Man(int age)
	{
		this.age = age; 

	}
	Man(int age,String name)
	{
		//上面已经写过了，是不是就可以进行调用了呢？答案是否定的
		this.Man(name);//this代表了对象，对象要想进行是使用必须先初始化，但是
		this.Man(age);//这里还没有进行初始化，就开始使用，所以是错误的

	}
	void run()
	{
		System.out.println(this.name+","+this.age);
	}
}
public class Main 
{	
	public static void main (String[] args) 
	{
		Man jo = new Man(12,"BLF");//此处传2个参数
		jo.run();
	}
}


修改

 

 

  1. class Man
  2. {
  3.     private int age;
  4.     private String name;
  5.     Man()
  6.     {
  7.         name= null;
  8.         age = 0;
  9.     }
  10.     Man(String name)
  11.     {
  12.         this.name = name;
  13.     }
  14.     Man(int age)
  15.     {
  16.         this.age = age;
  17.     }
  18.     Man(int age,String name)
  19.     {
  20.         this(name);//调用上述构造函数，注意：必须放第一行，房子this.age  = age;下面就错，理由见下
  21.         this.age = age;
  22.     }
  23.     void run()
  24.     {
  25.         System.out.println(this.name+”,”+this.age);
  26.     }
  27. }
  28. public class Main
  29. {
  30.     public static void main (String[] args)
  31.     {
  32.         Man jo = new Man(12,”BLF”);
  33.         jo.run();
  34.     }
  35. }
class Man
{
	private int age;
	private String name;
	Man()
	{
		name= null;
		age = 0;
	}
	Man(String name)
	{	
		this.name = name; 
	}
	Man(int age)
	{
		this.age = age; 
	}
	Man(int age,String name)
	{
		this(name);//调用上述构造函数，注意：必须放第一行，房子this.age  = age;下面就错，理由见下
		this.age = age;
	}
	void run()
	{
		System.out.println(this.name+","+this.age);
	}
}
public class Main 
{	
	public static void main (String[] args) 
	{
		Man jo = new Man(12,"BLF");
		jo.run();
	}
}

注意：this 规则：this只能定义在构造函数的第一行，因为初始化必须先执行 下述代码，this如果放下面

 

 

  1. Man(int age,String name)
  2. {
  3.     this.name = name;//初始化BLF
  4.     this.age = age;//初始化12
  6.     this(“gggg”); //改变BLF，变为gggg，故错误
  7. }
	Man(int age,String name)
	{
		this.name = name;//初始化BLF
		this.age = age;//初始化12

		this("gggg"); //改变BLF，变为gggg，故错误
	}

PS:this() 不要滥调用.
this的应用

 

 

  1. import java.security.cert.TrustAnchor;
  4. class Man
  5. {
  6.     private int age;
  7.     private String name;
  8.     Man()
  9.     {
  10.         name= null;
  11.         age = 0;
  12.     }
  13.     Man(String name)
  14.     {
  15.         this.name = name;
  16.     }
  17.     Man(int age)
  18.     {
  19.         this.age = age;
  20.     }
  21.     Man(int age,String name)
  22.     {
  23.         this(name);//调用上述构造函数，注意：见下
  24.         this.age = age;
  25.     }
  26.     public void run()
  27.     {
  28.         System.out.println(this.name+”,”+this.age);
  29.     }
  30.     /*判断两个人是否是同龄人*/
  31.     public boolean judge(Man g)
  32.     {
  33.         return this.age == g.age;//这里的this代表jo2
  35.     }
  36. }
  37. public class Main
  38. {
  39.     public static void main (String[] args)
  40.     {
  41.         Man jo = new Man(12,”BLF”);
  42.         Man jo2 = new Man(12,”BLF2″);
  43.         boolean flag = jo2.judge(jo);
  44.         if(flag==true)
  45.             System.out.println(“YES”);
  46.         else
  47.             System.out.println(“NO”);
  48.     }
  49. }