JAVA中this用法总结
2013-07-22 17:06:32| 分类： 技术类_JAVA|举报|字号 订阅
JAVA中this用法总结
1.强调本类中的方法
class Person{
private String name; //声明姓名属性
private int age; //声明年龄属性
public void tell(){ //取得信息的方法
System.out.println("姓名:"+getName()+",年龄："+getAge());
}
public String getName(){ //取得姓名
return name;
}
public String setName(String n){//设置姓名
name=n;
}
public String getAge(){ //取得年龄
return age;
}
public String setAge(int a){ //设置年龄
if(a>=&&a<150){ //年龄的验证
age=a;
};
}
}
public class Print{
public static void main(String args[]){
Person per=new Person(); //声明并实例化对象
per.setName("张三")； //调用setter设置姓名
per.setAge(-30); //调用setter设置年龄
per.tell(); //输出信息
}
}
正常情况下，类中的方法直接写上方法名称就可以完成本类中方法的调用，如果在此时非要强调是本类中的方法，也可以在调用时按"this.方法名称()"的形式编写
public void tell(){ //取得信息的方法
System.out.println("姓名:"+this.getName()+",年龄："+this.getAge());
}
在代码中是否使用this明确的表示当前类中的方法并没有严格的要求，但是这里建议最好使用"this.方法名称()"的形式，这样会比较标准一些，在查错时也会更加方便。
2.调用本类中的属性
范例：现在有以下的一个类
class Person{
private String name; //声明姓名属性
private int age; //声明年龄属性
public Person(String n,int a）{ //取得信息的方法
name=n;
age=a;
}
public String getInfo(){ //取得信息的方法
return"姓名:"+name+",年龄："+age;
}
}
在本类中构造方法的目的很明确，就是为类中的属性赋值，但是从构造方法的传递两个参数名称上很难看出n表示的意义或是a表示的意义，所以为了可以清楚地表示参数的意义，将以上的类修改为如下形式：
class Person{
private String name; //声明姓名属性
private int age; //声明年龄属性
public Person(String name,int age）{ //取得信息的方法
name=name;
age=age;
}
public String getInfo(){ //取得信息的方法
return"姓名:"+name+",年龄："+age;
}
}
此时，从参数名称上可以很清楚地知道，要传递的第一个参数是姓名，第二个是年龄，但这样又有新问题出现：
name=name;
age=age;
类的本意是要将参数传递的name值付给类中的name属性，将age 的值赋给age属性，但是程序并不能达到这样的效果。下面调用此类
public class Print{
public static void main(String args[]){
Person per=new Person("张三",33); //调用构造实例化对象
System.out.println(per1. getInfo ()); //取得信息
}
}
程序运行结果：姓名：null，年龄：0
也就是说并没有把从构造方法中传递进去的参数值赋给属性，证明现在的构造方法并不能成功地把传递进去的值赋给类中的属性，也就是说，在赋值时属性并不是明确地被指出，所以此时就可以利用this关键字，代码修改如下：
this.name=name;
this.age=age;
此时运行程序会得到结果：姓名：张三，年龄：33
构造方法中因为已经明确地表示出了类中的两个属性，所以赋值操作时也不会产生歧义。
另外：之前name=name时，两个name分别是什么呢？实际上，它们都是构造方法中的参数。例如你要拿笔写字，摆在面前的有一支笔，10米远处还有一支笔，你会选择哪支？肯定是近的那支。实际上程序也一样，在程序的构造方法中已经存在了name属性，那么在构造方法中如果要使用name属性，肯定要找近的，所以上面的两个那么，使用的都是构造方法中的参数。
所以建议在类中访问属性时都加上this关键字。
3.调用构造方法
如果一个类中有多个构造方法，也可以使用this关键字互相调用。
假设现在要求不管类中有多少个构造方法，只要对象一被实例化，就必须打印一行"一个新的对象被实例化"的信息出来，很明显，此时如果在各个构造方法中编写此输出语句肯定不合适，所以可以利用this关键字完成。如以下代码：
class Person{
private String name; //声明姓名属性
private int age; //声明年龄属性
public Person(）{ //无参构造
System.out.println("一个新的Person对象被实例化");
}
public Person(String name,int age）{ //取得信息的方法
this(); //在此处调用Person类中的无参构造方法
this.name=name;
this.age=age
}
public String getInfo(){ //取得信息
return"姓名:"+name+",年龄："+age;
}
}
public class Print{
public static void main(String args[]){
Person per=new Person("张三",33); //调用构造实例化对象
System.out.println(per1. getInfo ()); //取得信息
}
}
程序运行结果：
一个新的Person对象被实例化。
姓名：张三，年龄：33
本程序中提供了两个构造方法，其中有两个参数的构造方法使用this()形式调用本类中的无参构造方法，所以即使是通过有两个参数的构造方法实例化，最终结果还是会把对象实例化的信息打印出来。
如果把this()调用无参构造方法的位置任意调换，就可以在任何时候都可以调用构造方法了吗？实际上这样理解是错误的。构造方法是在实例化对象时自动被调用的。也就是说在类中的所有方法中，只有构造方法是被优先调用的，所以使用this调用构造方法必须也只能放在构造方法的第一行。下面的语句就是错误的。
public Person(String name,int age）{ //取得信息的方法
this.name=name;
this.age=age
this(); //在此处调用Person类中的无参构造方法
}
另外，this调用构造方法时一定要留一个构造方法作为出口，即程序中至少存在一个构造方法不使用this调用其他构造方法。
范例：错误的代码
class Person{
private String name; //声明姓名属性
private int age; //声明年龄属性
public Person(）{ //无参构造
this("XJY",30); //此处为错误的代码
System.out.println("一个新的Person对象被实例化");
}
public Person(String name）{ //无参构造
this();
}
public Person(String name,int age）{ //取得信息的方法
this(name);
this.age=age
}
public String getInfo(){ //取得信息
return"姓名:"+name+",年龄："+age;
}
}
上一段程序编译时会有错误提示递归调用了构造方法。所以在构造方法间互相调用时一定要留一个出口，一般都将无参构造方法作为出口，即在无参构造方法中最好不要再去调用其他构造方法。
4.表示当前对象
前面讲了何时使用this调用属性和调用方法，实际上在这些特性之外，this最重要的特点就是表示当前对象，在Java中当前对象就是指当前正在调用类中方法的对象。
（关于当前对象的解释：假设有ABC三人讲话，如果现在说话的人是A，则"当前正在说话的人"就是A，如果现在说话的人是B，则"当前正在说话的人"就是B，依此类推。所以只要是当前正在说话的人，就是当前对象）
范例：观察this表示当前对象
class Person{
private String name; //姓名
private int age; //年龄
public Person(String name,int age）{ //通过构造为属性赋值
this.setName(name);
this.setAge(age);
}
public String getName(){ //取得姓名
return name;
}
public String setName(String n){//设置姓名
name=n;
}
public String getAge(){ //取得年龄
return age;
}
public String setAge(int a){ //设置年龄
if(a>=&&a<150){ //年龄的验证
age=a;
};
}
}
此类中有name和age两个属性，现在要求产生两个Person对象，并且判断这两个对象是否相等，那么就会产生两个问题：如何进行对象的比较？在哪里进行对象的比较？对已第一个问题，要想进行对象的比较，必须比较其内容，但是Person中现在并不能使用equals方法，此时就需要对每一个属性进行依次的判断，如果所有属性的内容都相等，那么就可以证明这两个对象相等。这一点可以通过如下代码进行验证
范例：对象比较的第一种方式
public class Print{
public static void main(String[] args){
Person per1=new Person("张三",30); //声明两个对象，内容完全相等
Person per2=new Person("张三",30); //声明两个对象，内容完全相等
//直接在主方法中依次取得各个属性进行比较
if(per1.getName().equals(per2.getName())&&per1.getAge()==per2.getAge()){
System.out.println("两个对象相等！");
}else{
System.out.println("两个对象不相等！");
}
}
}
程序运行结果：两个对象相等！
以上程序确实完成了两个对象的比较功能，但是一个新的问题又来了：把所有的判断方法放在主方法中合适吗？这就是之前提到的第二个问题"在哪里进行对象的比较？"，可以做这样的一个比喻，假如现在有两个人，如果一个人要判断另一个人和自己是否相等，则肯定由这个人发出比较的请求，即在人这个类中就应该存在与其他人比较的方法。所以对象比较的方法应该放在Person类中，而不是放在main()方法中进行编写，修改后的代码如下：
class Person{
private String name; //姓名
private int age; //年龄
public Person(String name,int age）{ //通过构造为属性赋值
this.setName(name);
this.setAge(age);
}
public String getName(){ //取得姓名
return name;
}
public String setName(String n){//设置姓名
name=n;
}
public String getAge(){ //取得年龄
return age;
}
public String setAge(int a){ //设置年龄
if(a>=&&a<150){ //年龄的验证
age=a;
};
}
public boolean compare(Person per){
//调用此方法时里面存在两个对象：当前对象和传入的对象
Person p1=this; //表示当前调用方法的对象，为per1
Person p1=per; //传递到方法中的对象，为per2
if(p1==p2){ //首先比较两个地址是否相等
return true;
}
//分别判断每一个属性是否相等
if(p1.name.equals(p2.name)&&p1.age==p2.age){
return true; //两个对象相等
}else{
return false; //两个对象不相等
}
}
}
public class Print{
public static void main(String[] args){
Person per1=new Person("张三",30); //声明两个对象，内容完全相等
Person per2=new Person("张三",30); //声明两个对象，内容完全相等
if(per1.compare.per2)){
System.out.println("两个对象相等！");
}else{
System.out.println("两个对象不相等！");
}
}
}
以上程序Person类中定义了一个compare方法，此方法的主要功能就是专门完成两个对象性的比较操作，在比较时，首先进行地址的比较，如果地址一样，则肯定是同一对象，如果地址不等，则将一个个属性进行依次的比较。