精华内容
下载资源
问答
  • Java super关键字

    2019-03-29 17:35:45
    java中的super关键字是一个引用变量,用于引用直接父类对象。 每当创建子类的实例时,父类的实例被隐式创建,由super关键字引用变量引用。 java super关键字的用法如下: super可以用来引用直接父类的实例变量。 ...

    0 小结在先

    java中的super关键字是一个引用变量,用于引用直接父类对象。
    每当创建子类的实例时,父类的实例被隐式创建,由super关键字引用变量引用。
    java super关键字的用法如下:

    1. super可以用来引用直接父类的实例变量。
    2. super可以用来调用直接父类方法。
    3. super()可以用于调用直接父类构造函数。

    1 super用于引用直接父类实例变量

    可以使用super关键字来访问父类的数据成员或字段。 如果父类和子类具有相同的字段,则使用super来指定为父类数据成员或字段。

    class Animal {
        String color = "white";
    }
    
    class Dog extends Animal {
        String color = "black";
    
        void printColor() {
            System.out.println(color);// prints color of Dog class
            System.out.println(super.color);// prints color of Animal class
        }
    }
    
    class TestSuper1 {
        public static void main(String args[]) {
            Dog d = new Dog();
            d.printColor();
        }
    }
    

    执行上面代码,输出结果如下 -

    black
    white
    

    在上面的例子中,Animal和Dog都有一个共同的属性:color。 如果我们打印color属性,它将默认打印当前类的颜色。 要访问父属性,需要使用super关键字指定。

    2. 通过super 来调用父类方法

    uper关键字也可以用于调用父类方法。 如果子类包含与父类相同的方法,则应使用super关键字指定父类的方法。 换句话说,如果方法被覆盖就可以使用 super 关键字来指定父类方法。

    class Animal {
        void eat() {
            System.out.println("eating...");
        }
    }
    
    class Dog extends Animal {
        void eat() {
            System.out.println("eating bread...");
        }
    
        void bark() {
            System.out.println("barking...");
        }
    
        void work() {
            super.eat();
            bark();
        }
    }
    
    class TestSuper2 {
        public static void main(String args[]) {
            Dog d = new Dog();
            d.work();
        }
    }
    

    执行上面代码输出结果如下

    eating...
    barking...
    

    3. 使用 super 来调用父类构造函数

    super关键字也可以用于调用父类构造函数。下面来看一个简单的例子:

    class Animal {
        Animal() {
            System.out.println("animal is created");
        }
    }
    
    class Dog extends Animal {
        Dog() {
            super();
            System.out.println("dog is created");
        }
    }
    
    class TestSuper3 {
        public static void main(String args[]) {
            Dog d = new Dog();
        }
    }
    

    注意:如果没有使用super()或this(),则super()在每个类构造函数中由编译器自动添加。
    在这里插入图片描述
    我们知道,如果没有构造函数,编译器会自动提供默认构造函数。 但是,它还添加了super()作为第一个语句。
    下面是super关键字的另一个例子,这里super()由编译器隐式提供。

    class Animal {
        Animal() {
            System.out.println("animal is created");
        }
    }
    
    class Dog extends Animal {
        Dog() {
            System.out.println("dog is created");
        }
    }
    
    class TestSuper4 {
        public static void main(String args[]) {
            Dog d = new Dog();
        }
    }
    

    执行上面代码,输出结果如下 -

    animal is created
    dog is created
    

    super实际使用示例
    下面来看看super关键字的实际用法。 在这里,Emp类继承了Person类,所以Person的所有属性都将默认继承到Emp。 要初始化所有的属性,可使用子类的父类构造函数。 这样,我们重用了父类的构造函数。

    class Person {
        int id;
        String name;
    
        Person(int id, String name) {
            this.id = id;
            this.name = name;
        }
    }
    
    class Emp extends Person {
        float salary;
    
        Emp(int id, String name, float salary) {
            super(id, name);// 这里很关键!!!reusing parent constructor
            this.salary = salary;
        }
    
        void display() {
            System.out.println(id + " " + name + " " + salary);
        }
    }
    
    class TestSuper5 {
        public static void main(String[] args) {
            Emp e1 = new Emp(1, "ankit", 45000f);
            e1.display();
        }
    }
    

    执行上面代码,输出结果如下 -

    1 ankit 45000
    
    展开全文
  • super 也可以用在子类的子类中,Java 能自动向上层类追溯。父类行为被调用,就好象该行为是本类的行为一样,而且调用行为不必发生在父类中,它能自动向上层类追溯。super 关键字的功能:调用父类中声明为 private 的...

    super 关键字与 this 类似,this 用来表示当前类的实例,super 用来表示父类。

    super 可以用在子类中,通过点号(.)来获取父类的成员变量和方法。super 也可以用在子类的子类中,Java 能自动向上层类追溯。

    父类行为被调用,就好象该行为是本类的行为一样,而且调用行为不必发生在父类中,它能自动向上层类追溯。

    super 关键字的功能:

    调用父类中声明为 private 的变量。

    点取已经覆盖了的方法。

    作为方法名表示父类构造方法。

    调用隐藏变量和被覆盖的方法

    public class Demo{

    public static void main(String[] args) {

    Dog obj = new Dog();

    obj.move();

    }

    }

    class Animal{

    private String desc = "Animals are human's good friends";

    // 必须要声明一个 getter 方法

    public String getDesc() { return desc; }

    public void move(){

    System.out.println("Animals can move");

    }

    }

    class Dog extends Animal{

    public void move(){

    super.move(); // 调用父类的方法

    System.out.println("Dogs can walk and run");

    // 通过 getter 方法调用父类隐藏变量

    System.out.println("Please remember: " + super.getDesc());

    }

    }

    运行结果:

    Animals can move

    Dogs can walk and run

    Please remember: Animals are human's good friends

    move() 方法也可以定义在某些祖先类中,比如父类的父类,Java 具有追溯性,会一直向上找,直到找到该方法为止。

    通过 super 调用父类的隐藏变量,必须要在父类中声明 getter 方法,因为声明为 private 的数据成员对子类是不可见的。

    调用父类的构造方法

    在许多情况下,使用默认构造方法来对父类对象进行初始化。当然也可以使用 super 来显示调用父类的构造方法。

    public class Demo{

    public static void main(String[] args) {

    Dog obj = new Dog("花花", 3);

    obj.say();

    }

    }

    class Animal{

    String name;

    public Animal(String name){

    this.name = name;

    }

    }

    class Dog extends Animal{

    int age;

    public Dog(String name, int age){

    super(name);

    this.age = age;

    }

    public void say(){

    System.out.println("我是一只可爱的小狗,我的名字叫" + name + ",我" + age + "岁了");

    }

    }

    运行结果:

    我是一只可爱的小狗,我的名字叫花花,我3岁了

    注意:无论是 super() 还是 this(),都必须放在构造方法的第一行。

    值得注意的是:

    在构造方法中调用另一个构造方法,调用动作必须置于最起始的位置。

    不能在构造方法以外的任何方法内调用构造方法。

    在一个构造方法内只能调用一个构造方法。

    如果编写一个构造方法,既没有调用 super() 也没有调用 this(),编译器会自动插入一个调用到父类构造方法中,而且不带参数。

    最后注意 super 与 this 的区别:super 不是一个对象的引用,不能将 super 赋值给另一个对象变量,它只是一个指示编译器调用父类方法的特殊关键字。

    展开全文
  • super 关键字1、super是一个关键字,全部小写。2、super和this对比着学习。this:this能出现在实例方法和构造方法中。this的语法是:“this.”、“this()”this不能使用在静态方法中。this. 大部分情况下是可以省略的...

    super 关键字

    1、super是一个关键字,全部小写。

    2、super和this对比着学习。

    this:

    this能出现在实例方法和构造方法中。

    this的语法是:“this.”、“this()”

    this不能使用在静态方法中。

    this. 大部分情况下是可以省略的。

    this.什么时候不能省略呢? 在区分局部变量和实例变量的时候不能省略。

    public void setName(String name){

    this.name = name;

    }

    this() 只能出现在构造方法第一行,通过当前的构造方法去调用“本类”中

    其它的构造方法,目的是:代码复用。

    super:

    super能出现在实例方法和构造方法中。

    super的语法是:“super.”、“super()”

    super不能使用在静态方法中。

    super. 大部分情况下是可以省略的。

    super.什么时候不能省略呢? ???????

    super() 只能出现在构造方法第一行,通过当前的构造方法去调用“父类”中

    的构造方法,目的是:创建子类对象的时候,先初始化父类型特征。

    3、super()

    表示通过子类的构造方法调用父类的构造方法。

    模拟现实世界中的这种场景:要想有儿子,需要先有父亲。

    4、重要的结论:

    当一个构造方法第一行:

    既没有this()又没有super()的话,默认会有一个super();

    表示通过当前子类的构造方法调用父类的无参数构造方法。

    所以必须保证父类的无参数构造方法是存在的。

    5、注意:

    this()和super() 不能共存,它们都是只能出现在构造方法第一行。

    6、无论是怎样折腾,父类的构造方法是一定会执行的。(百分百的。)

    7、作用

    1、举个例子:在恰当的时间使用:super(实际参数列表);

    2、注意:在构造方法执行过程中一连串调用了父类的构造方法,父类的构造方法又继续向下调用它的父类的构造方法,

    但是实际上对象只创建了一个。

    3、思考:“super(实参)”到底是干啥的?

    super(实参)的作用是:初始化当前对象的父类型特征。并不是创建新对象。实际上对象只创建了1个。

    4、super关键字代表什么呀?

    super关键字代表的就是“当前对象”的那部分父类型特征。

    5、什么时候不能省略super

    父中有,子中又有,如果想在子中访问“父的特征”,super. 不能省略。

    java是怎么来区分子类和父类的同名属性的?

    this.name:当前对象的name属性

    super.name:当前对象的父类型特征中的name属性。

    包括 覆盖的方法

    6、什么时候不能用?

    //编译错误: 需要'.'

    //System.out.println(super);

    // this和super不能使用在static静态方法中。

    super 不是引用。super也不保存内存地址,super也不指向任何对象。

    super 只是代表当前对象内部的那一块父类型的特征。

    ps.

    super.属性名 【访问父类的属性】

    super.方法名(实参) 【访问父类的方法】

    super(实参) 【调用父类的构造方法】

    展开全文
  • 下面分享一下我对super关键字的使用总结。super限定对象调用从父类继承的实例变量和方法。子类继承父类,子类获得父类的成员变量和方法。分以下几种情况使用super关键字。一:限定子类对象使用父类被覆盖的方法。...

    下面分享一下我对super关键字的使用总结。

    super限定对象调用从父类继承的实例变量和方法。

    子类继承父类,子类获得父类的成员变量和方法。

    分以下几种情况使用super关键字。

    一:限定子类对象使用父类被覆盖的方法。

    子类继承父类,当父类方法不适合子类使用时,子类可以重写父类的方法,遵循“两同两小一大”的原则。

    代码演示:

    class Father {

    public void test() {

    System. out.println( "父类被覆盖的方法" );

    }

    }

    public class Son extends Father {

    // 重写父类的方法

    public void test() {

    System. out.println( "子类覆盖父类的方法" );

    }

    // super限定对象使用父类被覆盖的方法

    public void testOne() {

    super.test();

    }

    public static void main(String args[]) {

    Son son = new Son();

    son.test();

    son.testOne();

    }

    }

    使用super限定该对象调用父类被覆盖的方法。

    二:限定子类对象使用父类被被隐藏的实例变量。

    当子类中有一个和父类同名的实例变量时,父类的实例变量会被隐藏,如果想调用父类的实例变量则需要使用super限定该对象使用从父类继承得到的实例变量。

    代码演示:

    class Father {

    public int a = 10;

    }

    public class Son extends Father {

    public int a = 100;

    public void test() {

    System. out.println( super. a);

    }

    public static void main(String args[]) {

    Son son = new Son();

    // 调用实例变量,调用的是子类的实例变量

    System. out.println(son. a);

    // 调用父类被隐藏的实例变量

    son.test();

    }

    }

    三:调用父类的构造器

    子类不能继承父类的构造器,可以通过super限定调用父类的构造器,一般情况下,子类构造器默认在第一行隐式调用父类的无参构造器,如果父类包含有形参的构造器,则需要在子类构造器第一行显示调用父类的构造器。

    代码演示:

    class Father {

    public int age;

    public Father( int age){

    this. age=age;

    }

    }

    public class Son extends Father {

    public String name;

    public Son(int age,String name){

    //限定调用父类的构造器

    super(age);

    this. name=name;

    }

    public static void main(String args[]) {

    Son son = new Son(10, "王某某");

    System. out.println(son. age+son. name);

    }

    }

    创建对象时子类构造器总会调用父类构造器一次,如果不使用super,则会隐式调用父类的无参构造器,如果使用super,则会显示提调用父类的构造器,父类构造构造器也会先调用父类的父类的构造器,依次类推,最会隐式调用java.lang.object的无参构造器,所以父类的构造器总比子类的构造器先执行(子类构造器不显示调用父类构造器,就会有一个隐式super调用父类的无参构造器)。

    当通过this显示调用重载的构造器时,会先执行被重载的构造器。

    代码演示:

    class Father {

    public Father() {

    System.out.println("第一个被执行构造器");

    }

    }

    class Son extends Father {

    public int age;

    public String name;

    public Son(int age) {

    System.out.println("第二个被执行的构造器");

    }

    public Son(int age, String name) {

    this(age);

    this.name = name;

    System.out.println("第三个被执行的构造器");

    }

    }

    public class Grandson extends Son {

    public Grandson(int age, String name) {

    super(age, name);

    System.out.println("最后一个被执行的构造器");

    }

    public static void main(String args[]) {

    Grandson w = new Grandson(10, "wang");

    }

    }

    上面演示了super使用的三种情况,不足之处请大家指出,谢谢

    展开全文
  • 今天爱分享给大家带来java super关键字怎么用?【详细讲解】,希望能够帮助到大家。super可以理解为是指向自己超(父)类对象的一个指针,而这个超类指的是离自己最近的一个父类。super也有三种用法:1.普通的直接引用...
  • java super关键字

    千次阅读 2019-02-20 17:32:16
    super关键字有两种用途,分别是: 可以使用super关键字来访问父类的成员 如果你的子类重写了父类中的方法,你可以通过使用super关键字来回调父类中被重写的方法。你也可以使用super关键字来查询一个隐藏域。考虑...
  • 我们已经知道,如果子类中定义的成员变量和父类中的成员变量同名时,则父类中的成员变量不能被继承,...如果我们在子类中想使用被子类隐藏的父类的成员变量或方法就可以使用关键字super。因此,super是用在子类中,...
  • Java super关键字使用

    2017-05-16 15:44:36
    Java super关键字使用demo
  • 主要介绍了Java super关键字用法,结合具体案例形式分析了java super关键字调用父类构造方法、属性及方法等相关操作技巧与注意事项,需要的朋友可以参考下

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,245
精华内容 2,498
关键字:

javasuper关键字

java 订阅