Question

java中关键字 this 和super的作用及用法

请高手们给我讲一下Java中this和super的具体的用法和作用（要比较全面的），最好是有程序实例说明，谢谢
乁Freedom，您好，不知道您能不能把第二条关于构造器里面的用法在讲仔细一点，麻烦你了

Answer 1

Java关键字this、super使用总结

一、this
Java关键字this只能用于方法方法体内。当一个对象创建后，Java虚拟机（JVM）就会给这个对象分配一个引用自身的指针，这个指针的名字就是this。因此，this只能在类中的非静态方法中使用，静态方法和静态的代码块中绝对不能出现this，这在“Java关键字static、final使用总结”一文中给出了明确解释。并且this只和特定的对象关联，而不和类关联，同一个类的不同对象有不同的this。下面给出一个使用this的综合实例，以便说明问题：
package org.leizhimin;
public class Test6 {
private int number;
private String username;
private String password;
private int x = 100;
public Test6(int n) {
number = n; // 这个还可以写为: this.number=n;
}
public Test6(int i, String username, String password) {
// 成员变量和参数同名,成员变量被屏蔽,用"this.成员变量"的方式访问成员变量.
this.username = username;
this.password = password;
}
// 默认不带参数的构造方法
public Test6() {
this(0, "未知", "空"); // 通过this调用另一个构造方法
}
public Test6(String name) {
this(1, name, "空"); // 通过this调用另一个构造方法
}
public static void main(String args[]) {
Test6 t1 = new Test6();
Test6 t2 = new Test6("游客");
t1.outinfo(t1);
t2.outinfo(t2);
}
private void outinfo(Test6 t) {
System.out.println("-----------");
System.out.println(t.number);
System.out.println(t.username);
System.out.println(t.password);
f(); // 这个可以写为: this.f();
}
private void f() {
// 局部变量与成员变量同名,成员变量被屏蔽,用"this.成员变量"的方式访问成员变量.
int x;
x = this.x++;
System.out.println(x);
System.out.println(this.x);
}

//返回当前实例的引用
private Test6 getSelf() {
return this;
}
}

运行结果如下：

-----------
0
未知
空
100
101
-----------
0
游客
空
100
101

通过上面的例子，说明在什么情况下需要用到this：

第一、通过this调用另一个构造方法，用发是this(参数列表)，这个仅仅在类的构造方法中，别的地方不能这么用。
第二、函数参数或者函数中的局部变量和成员变量同名的情况下，成员变量被屏蔽，此时要访问成员变量则需要用“this.成员变量名”的方式来引用成员变量。当然，在没有同名的情况下，可以直接用成员变量的名字，而不用this，用了也不为错，呵呵。
第三、在函数中，需要引用该函所属类的当前对象时候，直接用this。
其实这些用法总结都是从对“this是指向对象本身的一个指针”这句话的更深入的理解而来的，死记不然容易忘记而且容易搞错，要理解！
二、super
super关键和this作用类似，是被屏蔽的成员变量或者成员方法或变为可见，或者说用来引用被屏蔽的成员变量和成员成员方法。
不过super是用在子类中，目的是访问直接父类中被屏蔽的成员，注意是直接父类（就是类之上最近的超类）。下面是一个综合运用super的例子，有两个类：一个Father类，一个Father类的子类Son，通过这两个类完全演示了super的用法，一下是代码：

package org.leizhimin;
public class Father {
public String v="Father";
public String x="输出了Father类的public成员变量x!!!";

public Father() {
System.out.println("Father构造方法被调用!");
}

public Father(String v){
this.v="Father类的带参数构造方法!运行了.";
}
public void outinfo(){
System.out.println("Father的outinfo方法被调用");
}
public static void main(String[] args) {
// TODO 自动生成方法存根
}
}

package org.leizhimin;
public class Son extends Father{
public String v="Son";

public Son() {
super(); //调用超类的构造方法,只能放到第一行.
System.out.println("Son无参数构造方法被调用!");
//super(); //错误的,必须放到构造方法体的最前面.
}

public Son(String str){
super(str);
System.out.println("Son带参数构造方法被调用!");
}
//覆盖了超类成员方法outinfo()
public void outinfo(){
System.out.println("Son的outinfo()方法被调用");
}

public void test(){

String v="哈哈哈哈!"; //局部变量v覆盖了成员变量v和超类变量v

System.out.println("------1-----");
System.out.println(v); //输出局部变量v
System.out.println(this.v); //输出(子类)成员变量v
System.out.println(super.v); //输出超类成员变量v

System.out.println("------2-----");
System.out.println(x); //输出超类成员变量v,子类继承而来
System.out.println(super.x); //输出超类成员变量v

System.out.println("------3-----");
outinfo(); //调用子类的outinfo()方法
this.outinfo(); //调用子类的outinfo()方法
super.outinfo(); //调用父类的outinfo()方法
}

public static void main(String[] args) {
new Son().test();

}
}

子类Son运行结果：

Father构造方法被调用!
Son无参数构造方法被调用!
------1-----
哈哈哈哈!
Son
Father
------2-----
输出了Father类的public成员变量x!!!
输出了Father类的public成员变量x!!!
------3-----
Son的outinfo()方法被调用
Son的outinfo()方法被调用
Father的outinfo方法被调用

说明：次例子仅仅为了说明super的用法，实际在设计类的时候一般都尽可能私有(private)化。

通过上面的例子，下面总结一下super的用法：
第一、在子类构造方法中要调用父类的构造方法，用“super(参数列表)”的方式调用，参数不是必须的。同时还要注意的一点是：“super(参数列表)”这条语句只能用在子类构造方法体中的第一行。
第二、当子类方法中的局部变量或者子类的成员变量与父类成员变量同名时，也就是子类局部变量覆盖父类成员变量时，用“super.成员变量名”来引用父类成员变量。当然，如果父类的成员变量没有被覆盖，也可以用“super.成员变量名”来引用父类成员变量，不过这是不必要的。
第三、当子类的成员方法覆盖了父类的成员方法时，也就是子类和父类有完全相同的方法定义（但方法体可以不同），此时，用“super.方法名(参数列表)”的方式访问父类的方法。

Answer 2

转 ：http://blog.csdn.net/anmei2010/article/details/4093118

super和this的异同：
1)super（参数）：调用基类中的某一个构造函数（应该为构造函数中的第一条语句）
2)this（参数）：调用本类中另一种形成的构造函数（应该为构造函数中的第一条语句）
3)super:　它引用当前对象的直接父类中的成员（用来访问直接父类中被隐藏的父类中成员数据或函数，基类与派生类中有相同成员定义时如：super.变量名 super.成员函数据名（实参）
4)this：它代表当前对象名（在程序中易产生二义性之处，应使用this来指明当前对象；如果函数的形参与类中的成员数据同名，这时需用this来指明成员变量名）

5）调用super()必须写在子类构造方法的第一行，否则编译不通过。每个子类构造方法的第一条语句，都是隐含地调用super()，如果父类没有这种形式的构造函数，那么在编译的时候就会报错。
　　 6）super()和this()类似,区别是，super()从子类中调用父类的构造方法，this()在同一类内调用其它方法。
　　 7）super()和this()均需放在构造方法内第一行。
　　 8）尽管可以用this调用一个构造器，但却不能调用两个。
　　 9）this和super不能同时出现在一个构造函数里面，因为this必然会调用其它的构造函数，其它的构造函数必然也会有super语句的存在，所以在同一个构造函数里面有相同的语句，就失去了语句的意义，编译器也不会通过。
　　 10）this()和super()都指的是对象，所以，均不可以在static环境中使用。包括：static变量,static方法，static语句块。
　　 11）从本质上讲，this是一个指向本对象的指针, 然而super是一个Java关键字。

Answer 3

this关键字
1)在类的内部代表对象本身，你应该看到过this.xxx(),this.xxx这种用法吧，
this就代表这个类的对象，比如
public class A {
private String name;
public void setName(String name) {
//this就代表A的一个对象
//当你实例一个A时,A a1 = new A();this就是那个a1，只是this在内部用，而a1在外部用
//A a2 = new A()同理，这时在a2的内部，this就代表a2
this.name = name;
}
}

2)this的第二种用法，是用在构造函数里的
当在构造器里要调用自己的其他构造器时，就用this
this必须放在第一行
public class A {
private String name;
public A() {
this("no name");
}

public A(String name) {
this.name = name;
//other codes
}
}

super关键字
1)显式的调用父类的方法
当从一个类继承时，子类和父类都有一个同名方法，也就是子类覆盖了父类的方法，可是又想调用父类的方法，那么就要用super，像继承swing的类时就有个好例子
public class MyPanel extends JPanel {
@Override
public void paint(Graphics g) {
super.paint(g);//如果不用super，那么就会调用自己的paint方法
}
}

2）用在构造器，和this的用法一样，super也可以用在构造器，this是调用自己的其他构造器，那么super当然就是调用父类的构造器了
-------------------------------------------------------

super和this用在构造器的话，前者表示调用父类的够早器，后者表示调用本类的其他构造器，他们两个都必须是写在构造器里的第一行

public class Person {
private String name;
private int age;
public Person() {
name = "";
age = 0;
}

public Person(String n, int a) {
name = n;
age = a;
}
}

public class Student extends Person {
private String id;//学号

public Student(String name, int age) {
super(name, age);//必须写在第一行，子类无法直接访问父类的私有属性，所以通过调用父类的构造器类初始化属性
}

public Student(String id, String name, int age) {
this(name, age);//因为本类已经有个构造器初始化name和age了，所以交给他来做就行了，也必须写在第一行
this.id = id;
}
}

这个例子够清晰了吧

Answer 4

1、super（参数）：调用基类中的某一个构造函数（应该为构造函数中的第一条语句）

2、this（参数）：调用本类中另一种形成的构造函数（应该为构造函数中的第一条语句）

3、super: 它引用当前对象的直接父类中的成员（用来访问直接父类中被隐藏的父类中成员数据或函数，基类与派生类中有相同成员定义时）

如：super.变量名

super.成员函数据名（实参）

4、this：它代表当前对象名（在程序中易产生二义性之处，应使用this来指明当前对象；如果函数的形参与类中的成员数据同名，这时需用this来指明成员变量名）

实例

class Point

{ private int x,y;

public Point(int x,int y)

{

this.x=x; //this它代表当前对象名

this.y=y;

}

public void Draw()

{

}

public Point()

{

this(0,0); //this（参数）调用本类中另一种形成的构造函数

}

}

class Circle extends Point

{

private int radius;

public circle(int x0,int y0, int r )

{

super(x0,y0); //super（参数）调用基类中的某一个构造函数

radius=r;

}

public void Draw()

{

super.Draw(); //super它引用当前对象的直接父类中的成员

drawCircle();

}}

Answer 5

this指的是当前类，super是指的父类。
作用就是在集成父类后，通过this和super确认调用的方式是属于当前类还是父类的。
用法：this/super.方法名（）；以此来区分调用方法是属于子类还是父类。