java 中 的 this 和 super

this

1. 构造函数中调用 this( 变量)   :意思就是说调用其他构造函数.

2.函数中用到了"this . 变量" 意思是成员变量和参数同名,成员变量被屏蔽,用"this.成员变量"的方式访问成员变量.

3.retun  this......引种自己的类,可以用this.

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

super

1.super(参数列表):这条语句只能用在子类构造方法体中的第一行,调用了父类(也叫超类)的构造函数.
2..super.成员变量名:调用了父类的这个变量.
3.super.方法名(参数列表)调用了父类这个方法

父类:

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 自动生成方法存根
 }
}

子类:

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);   //输出超类成员变量x,虽然子类没有这个变量,但是他继承了父类,所以有.
  System.out.println(super.x); //输出超类成员变量x,这个super直接就跑到父类那了.
  
  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方法被调用

总结区别.....this 和 super 用法可以说一样,但用处不同.

   this  理解为 这个的,它的;       就是说调用this的时候,可以一律看this做为这个class类.

 super 理解为   升格,上取;       当看到super的时候,可以一律看super作为 父类...是父类哦,不是自己这个类,是他的老爸.

public class DBUtil extends SQLiteOpenHelper {
	public DBUtil(Context context){      
		this(context,ConstantValue.DB_NAME,null,ConstantValue.DB_VERSION); //调用第四个构造函数
	}
	public DBUtil(Context context,int version){
		this(context,ConstantValue.DB_NAME,null,ConstantValue.DB_VERSION);//调用第四个构造函数
	}
	public DBUtil(Context context,String name,CursorFactory factory){
		this(context,ConstantValue.DB_NAME,null,ConstantValue.DB_VERSION);//调用第四个构造函数
	}
	public DBUtil(Context context,String name,CursorFactory factory,int version){
		super(context,ConstantValue.DB_NAME,null,ConstantValue.DB_VERSION);//调用SQLiteOpenHelper类的这个函数
	}

}