super( )的用法

1. super.XXX( 这里的XXX指的是父类的成员变量名即父类的属性，或者对象名)

2. super.XXX( ) ( 这里的XXX是父类中的其中一个方法名)

3. super( ) ( 这种形式指的是：调用父类没有参数的构造方法（也叫构造函数）注意： 这里super( ) 只能放在子类的构造方法里面，并且只能放在构造方法的首句)

4. super( x,y,z...) （此形式指：调用父类有参数的构造方法，也必须放在子类的构造方法（成员方法不可以）里面，并且只能放在构造方法的首句。其中x,y,z是指的与父类此有参构造方法中参数数据类型相对应的子类中的参数）

 

以下就是super( )的四种应用形式，具体的应用看以下代码：

 1. super的第一种应用形式即调用父类的成员变量：

package com.test;
 
public class Father {
	protected String head = "我的头又圆又大";
	Father(){	
            System.out.println(head);
	}
	Father(int a){
	    System.out.println(a);
	}
}

package com.test;
 
public class Son extends Father{
	private static int a = 1;
 
	public Son(){
		//super.head = " ";
		System.out.println(super.head);//调用父类Father中的属性head并且输出
		System.out.println(head);//调用父类Father中的属性head并且输出
		//super();
		//super(a);
	}
	public void test(){
		//super(int a);
		//super.head = "abc";
		//System.out.println(head);
	}
	public static void main(String[] args) {
		Son s = new Son();
		//s.test();
	}
}

以上代码的输出结果是：

可见：两条输出语句在控制台的输出结果相同，所以它们的作用是一样的。head就和super.head等价。但是平时为了方便不会把super.加上去。（这里的super.XXX和属性的访问修饰符不会发生冲突，也就是说父类的私有变量只能通过父类定义好的调用私有属性的方法去调用和改变，super关键字也无权调用）

 2. super的第二种应用形式即利用super关键字调用父类的无参构造方法：

package com.test;
 
public class Father {
	public String head = "我的头又圆又大";
	Father(){
		System.out.println(head);
	}
	Father(int a){
		System.out.println(a);
	}
} 

package com.test;
 
public class Son extends Father{
	private static int a = 1;
 
	public Son(){
		//super.head = " ";
		//System.out.println(super.head);//调用父类Father中的属性head并且输出
		//System.out.println(head);//调用父类Father中的属性head并且输出
		//super();
		//super(a);
	}
	public void test(){
		//super(int a);
		//super.head = "abc";
		//System.out.println(head);
	}
	public static void main(String[] args) {
		Son s = new Son();
		//s.test();
	}
}

其运行结果：

为什么在Son这个类中并没有一条输出语句，但是还是输出了一句话？就是因为用new关键字去创建对象的时候，会去调用此类的构造方法，而在此构造方法中的第一句，就默认为是：super( )，也就是去调用了父类的无参构造方法 这一句代码是自动加上去的，哪怕自己不在第一行写上：super( )，就像写一个类，如果不写这个类的构造方法的话，会自动加上一个public void修饰的，并且方法体为空的方法一样，当然自己加上也是可以的，但是加的时候必须要在子类构造方法的第一句。

 3. super的第三种应用形式即利用super关键字调用父类的有参构造方法：

package com.test;
 
public class Father {
    public String head = "我的头又圆又大";
 
    Father() {
        System.out.println(head);
    }
 
    Father(int a) {
        if (a == 1) {
            System.out.println("你们给我的参数是1");
        }
        if (a == 2) {
            System.out.println("你们给我的参数是2");
        }
    }
 
    Father(String str) {
        System.out.println("儿子，儿子~我是你爸爸");
 
    }
}

package com.test;
 
public class Son extends Father {
    private static int a = 1;
    
    private static String str = "ZwZ";
 
    public Son() {
        // System.out.println(super.head);//调用父类Father中的属性head并且输出
        // System.out.println(head);//调用父类Father中的属性head并且输出
        // super();
        super(a);//调用父类的，有参数的，并且参数为int类型的构造方法
        //super(str);
    }
    public Son(String str){
        super(str);//调用父类的，有参数的，并且参数为String类型的构造方法
    }
 
    public void test() {
        // super(int a);
        // super.head = "abc";
        // System.out.println(head);
    }
 
    public static void main(String[] args) {
        Son s = new Son();
        Son s2 = new Son(str);
        // s.test();
    }
}

其运行结果为：

可见super( )和super（str）分别调用了父类的Father( )和Father( String str )两个构造方法

4. super的第四种应用形式即利用super关键字调用父类的成员方法：

package com.test;
 
public class Father {
	public String head = "我的头又圆又大";
 
	Father() {
		System.out.println(head);
	}
 
	Father(int a) {
		if (a == 1) {
			System.out.println("你们给我的参数是1");
		}
		if (a == 2) {
			System.out.println("你们给我的参数是2");
		}
	}
 
	Father(String str) {
		System.out.println("儿子，儿子~我是你爸爸");
	}
 
	public static String demo(String str) {
 
		System.out.println(str);
		return str;
	}
}

package com.test;
 
public class Son extends Father {
	private static int a = 1;
 
	private static String str = "我叫张文哲";
 
	/*
	 * public Son() { System.out.println(super.head);//调用父类Father中的属性head并且输出
	 * System.out.println(head);//调用父类Father中的属性head并且输出 super();
	 * super(a);//调用父类的，有参数的，并且参数为int类型的构造方法 }
	 */
	public Son(String str) {
		// super(str);//调用父类的，有参数的，并且参数为String类型的构造方法
		String strCopy = super.demo(str);// 调用父类的成员方法demo，并且用strCopy接收此方法返回的字符串
 
		System.out.println(strCopy);// 输出strCopy接收的内容以验证
	}
 
	public static void main(String[] args) {
		// Son s = new Son();
		Son s2 = new Son(str);
	}
}

以上代码的输出结果：

又以上结果可知，理论与实践相符！！！（其中“我的头又大又圆”这句话之所以输出，是因为在Son（String str）此构造方法里面自动加上了super（）而在Father( )里面有向控制台输出的语句。）

写在后面，注意：

     1. 在子类的构造方法里面，super( )和super( x,y,z...)这能用其中一个，（其他两种没有这种要求），否则编译器会报错

     2.在构造子类对象的同时，会构造父类对象。（因为在调用自类构造方法的时候，第一句代码默认的便是super（），它调用了父类的构造方法）