一、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.方法名(参数列表)”的方式访问父类的方法。
对，没重写那super.add() 和this.add() 都是调的父类的方法， 没什么区别，如果重写了this.add()就默认调本类的方法，super就默认调父类的方法，
再在子类中，都不写的话，如果有重写父类的add()方法的话就默认调本类的add()方法， 如果本类没有重写就调父类的方法，
其实这种问题建议你直接写一个小代码一目了然，比如：
class A{
void add(){
System.out.println("天下无双")
}
}
class B extends A{
void add(){
System.out.println("天下无贼")
}
void aa(){
add()
super.add()
}
}
public class aaaaaaa {
public static void main(String[] args) {
A a=new A()
B b=new B()
b.aa()
}
}
你可以试试， 我也是新手， 对这种问题还是比较喜欢自己动手， 听别人说总有点云里雾里的， 可以加我Q互相讨论一下494792360
区别不大
因为所有类如果没声明构造方法，默认是有个无参数构造方法
所以图片中其实是这样的，以子类BomBird构造为例子
public BomBird(ShoutAbility shout_ability){
super()//默认这里是省略的但是前提是父类有无参数构造方法
this.shout_ability=shout_ability//子类继承父类所以可以用this，你也可以super.shout_ability=shout_ability
}
你说的后者写法也没错，效率没有太大区别
写法可以有很多，但是不能说一定要怎么写，多方面考虑
但是更好的是对父类的封装，抽象为父类是为了封装一系列共有通用属性，变量因情况而定可以是private protected修饰，提供set和get方法，这个东西现在没法说清楚，不同的代码环境有不同的写法，只有慢慢积累，你每个写法都要知道，以后在工作中，代码扩展中自然能看出各种写法优劣，才能更面向对象，更具有扩展性！
比如接口定义行为标准，这些东西不是一下就能让你明白的，
欲速不达的道理，主要是平时自己多写写，多看看其他成功代码，想下别人为什么这样写，为什么不那样写，各个的优缺点，慢慢积累
