Java教程

032:Java super关键字详解

本文主要是介绍032:Java super关键字详解,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

Java super关键字详解

(转自:http://c.biancheng.net/view/940.html)

由于子类不能继承父类的构造方法,因此,如果要调用父类的构造方法,可以使用 super 关键字。super 可以用来访问父类的构造方法、普通方法和属性。

这里复习一下构造方法:创建:public class_name(){};用来初始化类的一个新的对象,使用 new 关键字来调用构造方法。调用有参的构造方法:Worker worker2 = new Worker("李丽",25);
super 关键字的功能:

  • 在子类的构造方法中显式的调用父类构造方法
  • 访问父类的成员方法和变量。

1      super调用父类构造方法

super 关键字可以在子类的构造方法中显式地调用父类的构造方法,基本格式如下:

super(parameter-list);

其中,parameter-list 指定了父类构造方法中的所有参数。super( ) 必须是在子类构造方法的方法体的第一行。

例1

声明父类 Person 和子类 Student,在 Person 类中定义一个带有参数的构造方法,代码如下:

  1. //创建类
  2. public class Person {
  3.   //创建构造方法,带有参数
  4.     public Person(String name) {
  5.  
  6.     }
  7. }
  8. //Student继承Person父类
  9. public class Student extends Person {
  10. 10.  

11. }

会发现 Student 类出现编译错误,提示必须显式定义构造方法,错误信息如下:

Implicit super constructor Person() is undefined for default constructor. Must define an explicit constructor

在本例中 JVM 默认给 Student 类加了一个无参构造方法,而在这个方法中默认调用了 super(),但是 Person 类中并不存在该构造方法,所以会编译错误。
如果一个类中没有写任何的构造方法,JVM 会生成一个默认的无参构造方法。在继承关系中,由于在子类的构造方法中,第一条语句默认为调用父类的无参构造方法(即默认为 super(),一般这行代码省略了)。所以当在父类中定义了有参构造方法,但是没有定义无参构造方法时,编译器会强制要求我们定义一个相同参数类型的构造方法。

例2

声明父类 Person,类中定义两个构造方法。示例代码如下:

  1. //定义类
  2. public class Person {
  3.   //定义构造方法,含有两个参数
  4.     public Person(String name, int age) {
  5.     }
  6.     public Person(String name, int age, String sex) {
  7.     }
  8. }

子类 Student 继承了 Person 类,使用 super 语句来定义 Student 类的构造方法。示例代码如下:

  1. public class Student extends Person {
  2.     public Student(String name, int age, String birth) {
  3.         super(name, age); // 调用父类中含有2个参数的构造方法
  4.     }
  5.     public Student(String name, int age, String sex, String birth) {
  6.         super(name, age, sex); // 调用父类中含有3个参数的构造方法
  7.     }
  8. }

从上述 Student 类构造方法代码可以看出,super 可以用来直接调用父类中的构造方法,使编写代码也更加简洁方便。
编译器会自动在子类构造方法的第一句加上super();来调用父类的无参构造方法,必须写在子类构造方法的第一句,也可以省略不写。通过 super 来调用父类其它构造方法时,只需要把相应的参数传过去。

2      super访问父类成员

当子类的成员变量或方法与父类同名时,可以使用 super 关键字来访问。如果子类重写了父类的某一个方法,即子类和父类有相同的方法定义,但是有不同的方法体,此时,我们可以通过 super 来调用父类里面的这个方法
使用 super 访问父类中的成员与 this 关键字的使用相似,只不过它引用的是子类的父类,语法格式如下:

super.member

其中,member 是父类中的属性或方法。使用 super 访问父类的属性和方法时不用位于第一行。

super调用成员属性

当父类和子类具有相同的数据成员时,JVM 可能会模糊不清。我们可以使用以下代码片段更清楚地理解它。

  1. class Person {
  2.     int age = 12;
  3. }
  4. //类的继承
  5. class Student extends Person {
  6.     int age = 18;
  7.  
  8.     void display() {
  9.         System.out.println("学生年龄:" + super.age);
  10. 10.     }

11. }

  1. 12.  

13. class Test {

  1. 14.     public static void main(String[] args) {
  2. 15.         Student stu = new Student();
  3. 16.         stu.display();
  4. 17.     }

18. }

输出结果为:

学生年龄:12

在上面的例子中,父类和子类都有一个成员变量 age。我们可以使用 super 关键字访问 Person 类中的 age 变量。

super调用成员方法

当父类和子类都具有相同的方法名时,可以使用 super 关键字访问父类的方法。具体如下代码所示。

  1. 1.    class Person {
    2.        int age = 12;
    3.    }
    4.    //类的继承
    5.    class Student extends Person {
    6.        int age = 18;
    7.    
    8.        void display() {
    9.            System.out.println("学生年龄:" + super.age);
    10.        }
    11.    }
    12.    
    13.    class Test {
    14.        public static void main(String[] args) {
    15.            Student stu = new Student();
    16.            stu.display();
    17.        }
    18.    }

    输出结果为:

This is student class
This is person class

在上面的例子中,可以看到如果只调用方法 message( ),是当前的类 message( ) 被调用,使用 super 关键字时,是父类的 message( ) 被调用。

3. super和this的区别(重点总结)

this 指的是当前对象的引用,super 是当前对象的父对象的引用。下面先简单介绍一下 super 和 this 关键字的用法。
super 关键字的用法:

  • super.父类属性名:调用父类中的属性
  • super.父类方法名:调用父类中的方法
  • super():调用父类的无参构造方法
  • super(参数):调用父类的有参构造方法
    如果构造方法的第一行代码不是 this() 和 super(),则系统会默认添加 super()
    this 关键字的用法:
  • this.属性名:表示当前对象的属性
  • this.方法名(参数):表示调用当前对象的方法
    当局部变量和成员变量发生冲突时,使用this.进行区分。
    关于 Java super 和 this 关键字的异同,可简单总结为以下几条。
  1. 子类和父类中变量或方法名称相同时,用 super 关键字来访问。可以理解为 super 是指向自己父类对象的一个指针。在子类中调用父类的构造方法。
  2. this 是自身的一个对象,代表对象本身,可以理解为 this 是指向对象本身的一个指针。在同一个类中调用其它方法。
  3. this 和 super 不能同时出现在一个构造方法里面,因为 this 必然会调用其它的构造方法,其它的构造方法中肯定会有 super 语句的存在,所以在同一个构造方法里面有相同的语句,就失去了语句的意义,编译器也不会通过。
  4. this( ) 和 super( ) 都指的是对象,所以,均不可以在 static 环境中使用,包括 static 变量、static 方法和 static 语句块。
  5. 从本质上讲,this 是一个指向对象本身的指针, 然而 super 是一个 Java 关键字。

例 3

在 Animal 类和 Cat 类中分别定义了 public 类型的 name 属性和 private 类型的 name 属性,并且 Cat 类继承 Animal 类。那么,我们可以在 Cat 类中通过 super 关键字来访问父类 Animal 中的 name 属性,通过 this 关键字来访问本类中的 name 属性,如下面的代码:

  1. // 父类Animal的定义
  2. public class Animal {
  3.     public String name; // 动物名字
  4. }
  5.  
  6. //子类Cat的定义
  7. public class Cat extends Animal {
  8.     private String name; // 名字
  9.  
  10.      public Cat(String aname, String dname) {
  11.       super.name = aname; // 通过super关键字来访问父类中的name属性
  12.        this.name = dname; // 通过this关键字来访问本类中的name属性
  13.     }
  14.   
  15.    public String toString() {
  16.        return "我是" + super.name + ",我的名字叫" + this.name;
  17.      }
  18.  
  19.    public static void main(String[] args) {
  20.         Animal cat = new Cat("动物", "喵星人");
  21.       System.out.println(cat);
  22.    }

23. }

上述代码演示了使用 super 关键字访问父类中与子类同名的成员变量 name,this 关键字访问本类的 name 变量。运行程序,输出结果如下:

我是动物,我的名字叫喵星人

 

这篇关于032:Java super关键字详解的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!