展开全部
在father中在定义一个62616964757a686964616fe59b9ee7ad9431333335313738调用父类的方法，在子类逐级调用。。。class GrandPa
{
void Method()
{
System.out.println("Hello,   I   am   GrandPa! ");
}
}
class Father extends GrandPa
{
void Method()
{
System.out.println("Hello,   I   am   Father! ");
}
/** 定义一个调用父类的方法 */
void getParentMethod()
{
super.Method();
}
}
class Son extends Father
{
void Method()
{
/** 这么逐级调用就可以了 */
super.getParentMethod();
System.out.println("And   Son   is   followed! ");
}
public static void main(String[] args)
{
Son son = new Son();
son.Method();
}
}

这篇文章主要介绍了Java super关键字调用父类过程解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
话不多说，直接上代码：
package com.my.pac14;
/**
* @auther Summerday
*/
public class SuperTest {
public static void main(String[] args) {
SubClass sb = new SubClass(20);
//创建子类的对象，调用子类的print方法
sb.print();
}
}
class BaseClass {
public int a = 5;
public int b;
static public int c = 30;
BaseClass(int b) {
this.b = b;
System.out.println("superb:" + this.b);
}
public void print() {
System.out.println("父类的a = " + a);
//System.out.println(this.a);
}
public void read() {
System.out.println("read..");
}
}
class SubClass extends BaseClass {
public int a = 10;
//子类中的实例变量将父类中的隐藏，所以下面的this.b=0
public int b;
static public int c = 40;
SubClass(int b) {
//调用父类的构造器
super(b);//20
System.out.println("superb:" + super.b + "，subb:" + this.b);//0
}
public void print() {
//打印父类中的a=5
System.out.println(super.a);//5
//调用父类的print方法，打印a=5
super.print();//5
//直接打印a，会打印出当前类的a，打印子类的a=10
System.out.println("子类的a = " + a);
//类变量也会覆盖
System.out.println(c);
//用父类名访问父类的类变量
System.out.println("父类中的类变量c = " + BaseClass.c);
//没有重写，不需要使用super调用父类方法
read();
}
}
super用于限定该对象调用从父类继承得到的实例变量或方法，因此和this相同的是，super不能出现在static修饰的方法中。(因为static修饰的方法属于类，调用者将会是类，而不是一个对象)
调用父类成员变量
实例变量
可以直接利用super.xx限定访问父类的实例变量。
//父类
public int a = 5;
//子类
public int a = 10;
//在子类中访问父类的实例变量
public void print() {
//打印父类中的a=5
System.out.println(super.a);//5
//直接打印a，会打印出当前类的a，打印子类的a=10
System.out.println("子类的a = " + a);
}
类变量
如果父类变量是用static修饰的类变量，则需要用父类类名.xx限定访问其类变量。(虽然可以使用super访问父类中的类变量，就像我们之前说的用类的实例访问类变量，但是极不规范，不建议。)
//父类
static public int c = 30;
//子类
static public int c = 40;
//在子类中访问父类的类变量
public void print() {
//类变量也会隐藏
System.out.println(c);
//用父类名访问父类的类变量
System.out.println("父类中的类变量c = " + BaseClass.c);
}
总结：
子类中没有包含和父类同名的成员变量，就无需使用super或父类名显式调用。
如果在没够方法中访问某成员变量，但没有显式指定调用者，则查找该成员变量的顺序：
查找该方法中有没有。
查找该类中有没有。
查找父类中有没有。
……
如果没有找到，就会报错。
当创建一个子类对象时，系统不仅会为该类中定义的实例变量分配内存，也会为它从父类继承得到的所有实例变量分配内存，即使子类定义了与父类中同名的实例变量。所以，子类中定义与父类同名的实例变量并不会完全覆盖父类中定义的实例变量，只是简单地隐藏。
调用父类的方法
我们之前说过，子类中定义与父类同名且参数列表相同的实例方法(static方法不能被重写)就是所谓的方法重写，此时子类的方法会覆盖父类的方法。
在子类中想调用父类的同名实例方法，可以利用：super.父类方法名；
如果是类方法，则可以用父类名.父类方法名调用。(super依旧可以，但不建议)
如果没有同名，就不需要显式用super调用父类方法。
//父类
public void print() {
System.out.println("父类的a = " + a);
//System.out.println(this.a);
}
public void read() {
System.out.println("read..");
}
//子类
public void print() {
//调用父类的print方法，打印a=5
super.print();//5
//没有重写，不需要使用super调用父类方法
read();
}
调用父类构造器
关于子类中利用super关键字调用父类构造器，在上一篇中，已经做出总结，具体可参看：Java继承构造器使用过程解析
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持聚米学院。

由于子类不能继承父类的构造方法，因此，要调用父类的构造方法，必须在子类的构造方法体的第一行使用 super() 方法。该方法会调用父类相应的构造方法来完成子类对象的初始化工作。
在以下情况下需要使用 super 关键字：
在类的构造方法中，通过 super 语句调用该类的父类的构造方法。
在子类中访问父类中的成员。
使用 super 调用父类的构造方法
子类可以通过 super 关键字来调用一个由父类定义的构造方法，格式如下：
super(parameter-list);
其中，parameter-list 指定了父类中构造方法所需的所有参数。super() 必须是在子类构造方法的主体第一行。
例如，在 Person 类中指定了两个构造方法。示例代码如下：
public People(String name,int age,String sex,String sn)
{
this.name=name;
this.age=age;
this.sex=sex;
this.sn=sn;
}
public People(String name,String sn)
{
this.name=name;
this.sn=sn;
}
那么，Student 类继承了 Person 类，就可以使用 super 语句来定义 Student 类的构造方法。示例代码如下：
public Student(String name,int age,String sex,String sn,String stuno,String department)
{
super(name,age,sex,sn);    //调用父类中含有4个参数的构造方法
this.stuNo=stuno;
this.department=department;
}
public Student(String name,String sn,String stuNo)
{
super(name,sn);    //调用父类中含有两个参数的构造方法
this.stuNo=stuNo;
}
从上述 Student 类构造方法代码可以看出，super 用来直接调用父类中的构造方法，使用它可以使书写代码更简洁方便。
使用 super 访问父类成员
使用 super 访问父类中的成员与 this 关键字的使用相似，只不过它引用的是子类的父类，基本形式如下：
super.member
其中，member 是父类中的方法或属性名称。这种形式多用于子类的成员名隐藏了父类中的同名成员的情况。
例 1
在 Animal 类和 Cat 类中分别定义了 public 类型的 name 属性和 private 类型的 name 属性，并且 Cat 类继承 Animal 类。那么，我们可以在 Cat 类中通过 super 关键字来访问父类 Animal 中的 name 属性，通过 this 关键字来访问本类中的 name 属性，如下面的代码：
//父类Animal的定义
public class Animal
{
public String name;    //动物名字
}
//子类Cat的定义
public class Cat extends Animal
{
private String name;    //名字
public Cat(String aname,String dname)
{
super.name=aname;    //通过super关键字来访问父类中的name属性
this.name=dname;    //通过this关键字来访问本类中的name属性
}
public String toString()
{
return"我是"+super.name+"，我的名字叫"+this.name;
}
public static void main(String[] args)
{
Animal cat=new Cat("动物","喵星人");
System.out.println(cat);
}
}
上述代码演示了使用 super 实现子类的成员名隐藏父类中同名成员的情况。尽管 Cat 类中的属性 name 隐藏了 Animal 类中的 name 属性，但是 super 允许访问父类中的 name 属性。另外，super 还可以用于调用被子类隐藏的方法。
运行程序，输出结果如下：
我是动物，我的名字叫喵星人

Java构造函数中显示的调用父类A的有参构造函数
点击次数:1571  更新日期:2013-03-16
class Person
public Person
}
class Student extends Person
public Student
public Student
}
class Test
}
/
=======================================
输出如下：
E：“JavaWorkjava Test
st1：
person无参数构造函数
student 无参数的构造函数
---------------------------
st2：
person无参数构造函数
student 3 参数的构造函数
---------------------------
st3：
person 2 参数的构造函数
student 4 参数的构造函数，super.
说明了创建一个子类的对象实例的时候，必先调用父类的无参数的构造函数(默认构造函数)，假如父类有带参数的构造函数，那么系统将不会给它创建无参数的构造函数，这时，子类在实例化的时候，因为找不到父类的默认构造函数，编译器将会报错，但假如在子类的构造函数中指定用父类的带参数的构造函数的时候，或者在父类中加一个无参数的构造函数，就不会报错。
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
我们假设A是B的父类，B是A的子类。
1、假如程序员没有给类A没有提供构造函数，则编译器会自动提供一个默认的无参数的构造函数，假如用户提供了自己的构造函数，则编译器就不在提供默认的无参数构造函数。
2、子类B实例化时会自动调用父类A的默认构造函数，所以假如A的默认的无参数的构造函数为private，则编译器会报错，而假如A没有提供默认的无参数的构造函数，而提供了其他类型的构造函数，编译器同样会报错，因为B找不到A的默认无参数构造函数。所以，我们最好给父类A提供一个无参数的构造函数。
3、或者在B的构造函数中显示的调用父类A的有参构造函数。
\n\n\n