如题，具体的差异是什么？

this只能用在非静态方法中，因为在编译的时候java虚拟机会分配一个指针指向引用自身实例对象，
在一个方法内有局部变量跟成员变量名字一样的时候，this可以用来指定出被隐藏的成员变量，如
public void setName(){
}

晕，好像按错键了，下面接着
public void setName(String name){
     this.name = name;
}
这是最常见的this用法，就是为了指定出被隐藏的成员变量。
还有就是在构造方法内使用this(参数列表)调用其他构造方法，如
public  Person(String name,int age,String sex){
    this(name,age);
     ……
}
super用法跟this差不多，super是用于找出父类中被隐藏的成员变量，
super(参数列表);只能用于子类构造函数中格的第一行

this是当前类的引用吧
super是指调用父类的构造函数
如：
public class Student extends SuperStudent{
　　private int id;
　　private String name;
　　//省略setget方法
　　public Student(int id){
　　　　this.id = id;
　　}
　　public Sthdent(int id,String name){
　　　　this(1);// 此处调用的是当前的相对应的构架函数
　　　　this.name = name;
　　　　super(id,name,"男");// 此处就是调用父类SuperStudent中的构造函数
　　}
}

SuperStudent类
public class SuperStudent{
　　private int id;
　　private String name;
　　private String sex;

　　// 省略 set get
　　
　　public SuperStudent(int id,String name,String sex){
　　　　this.id = id;
　　　　this.name = name;
　　　　this.sex = sex;
　　}
}

this 可以说是代表传入未知对象的一种变量

super 是父类啊。

"this"的用法
构造器和方法使用关键字this有很大的区别。方法引用this指向正在执行方法的类的实例。静态方法不能使用this关键字，因为静态方法不属于类的实例，所以this也就没有什麽东西去指向。构造器的this指向同一个类中，不同参数列表的另外一个构造器，我们看看下面的代码：
public class Platypus {
String name;
Platypus(String input) {
name = input;
}

Platypus() {
this("John/Mary Doe");
}

public static void main(String args[]) {
Platypus p1 = new Platypus("digger");
Platypus p2 = new Platypus();
}
}
在上面的代码中，有2个不同参数列表的构造器。第一个构造器，给类的成员name赋值，第二个构造器，调用第一个构造器，给成员变量name一个初始值 "John/Mary Doe".
在构造器中，如果要使用关键字this,那麽，必须放在第一行，如果不这样，将导致一个编译错误。
"super"的用法
构造器和方法，都用关键字super指向超类，但是用的方法不一样。方法用这个关键字去执行被重载的超类中的方法。看下面的例子：
class Mammal {
void getBirthInfo() {
System.out.println("born alive.");
}
}

class Platypus extends Mammal {
void getBirthInfo() {
System.out.println("hatch from eggs");
System.out.print("a mammal normally is ");
super.getBirthInfo();
}
}

在上面的例子中，使用super.getBirthInfo()去调用超类Mammal中被重载的方法。
构造器使用super去调用超类中的构造器。而且这行代码必须放在第一行，否则编译将出错。看下面的例子：
public class SuperClassDemo {
SuperClassDemo() {}
}

class Child extends SuperClassDemo {
Child() {
super();
}
}

在上面这个没有什麽实际意义的例子中，构造器 Child()包含了 super,它的作用就是将超类中的构造器SuperClassDemo实例化，幷加到 Child类中。
编译器自动加入代码
编译器自动加入代码到构造器，对于这个，java程序员新手可能比较混淆。当我们写一个没有构造器的类，编译的时候，编译器会自动加上一个不带参数的构造器，例如：public class Example {}
编译后将如下代码：
public class Example {
Example() {}
}
在构造器的第一行，没有使用super，那麽编译器也会自动加上，例如：
public class TestConstructors {
TestConstructors() {}
}
编译器会加上代码，如下：

public class TestConstructors {
TestConstructors() {
super;
}
}

仔细想一下，就知道下面的代码

public class Example {}

经过会被编译器加代码形如：

public class Example {
Example() {
super;
}
}

this关键字代表自身,super关键字可以在子类中引用父类的内容。
this
•使用this关键字引用成员变量。
•使用this关键字在自身构造方法内部引用其他构造方法。
•使用this关键字代表自身类的对象。
•使用this关键字引用成员方法
super
•在子类的构造方法内部引用父类的构造方法。
•在子类中调用父类中的成员方法。
•在子类中调用父类中的成员变量。

先要明白他们的使用范围，this出现在类的构造方法中，谁调用这个方法，this就指向谁，其实this代表的是调用这个方法的对象；super它使用在父类与子类之间的构造方法内，所以它的出现一定会牵涉到继承关系，在子类的内部，如果要使用父类的成员，直接用super代表父类调用父类的成员变量或者成员方法即可得到子类的成员数据。。。

如果子类中出现非私有的同名成员变量时，比如子类的num和Fu类中的num重名
子类要访问本类中的变量，用this
子类要访问父类的变量，用super
super的使用和this的使用几乎一致
this代表着对本类对象的引用
super代表着父类对象的引用。

简单一句话概括了：this表示当前对象，super表示父类对象。

this 变量使用在一个成员函数的内部，指向当前对象；super 变量是直接指向父类的构造函数，用来引用父类的变量和方法。
this还有一个用法，就是构造函数的第一个语句，它的形式是 this(参数表)，这个构造函数就会调用同一个类的另外一个相同的构造函数。

this代表当前对象，super代表父类
例如
super.excute();则表示调用父类的excute方法

this 指引用本类的对象。
super 指引用父类的对象。
默认的情况下子类在创建时，其构造方法中都要先调用父类的无参构造方法，在执行子类的构造方法中的代码块。而且子类的创建必调用父类的构造方法。

1,thid可以在构造方法中使用,比如调用其他构造方法:
public A(){
this("name")
}
2,this可以代表本类对象,
Super用于调用父类的方法.

Super调用超类的构造方法，如多层继承中的构造方法的调用顺序
使用super调用超类被子类覆盖的方法;
使用super访问被子类隐藏的变量;

This,将对象自己作为参数，调用别的方法;当方法的局部变量隐藏成变量时，利用this引用成员变量;
在构造方函数内调用另一个构函数

this关键字代表自身,super关键字可以在子类中引用父类的内容。


this
使用this关键字引用成员变量。
使用this关键字在自身构造方法内部引用其他构造方法。
使用this关键字代表自身类的对象。
使用this关键字引用成员方法



super
在子类的构造方法内部引用父类的构造方法。
在子类中调用父类中的成员方法。
在子类中调用父类中的成员变量。

纯手打，请区分。
这两个经典的关键字其实很好区分，看名字就已经了解大概了
this -- 代表的说白了就是它自己，经典的使用方法是bean文件中
static Object o = null;
public Object setXXX(Obejct o) {
  this.o = o;
}
虽然出现了两个Object o，但是你仅仅用一个this就区分开了该类的成员变量和该类的成员方法中定义的接受参数，很Cool不是么。


而super，指的则是该类的父类，利用super可以点出父类的成员变量、成员方法以及构造函数。


此外，你一样可以写全包名与类名，来表明你现在正在使用的成员变量是谁，例如在一个构造函数中：

public class test () {
  static int a = 1;
  test () {
    System.out.println(this.a == com.javaTest.test.a);
  }
  new test();
}
打印结果将为true