精华内容
下载资源
问答
  • 主要介绍了java之super关键字用法实例解析,较为详细的分析了super关键字的用法及内存分布,需要的朋友可以参考下
  • 主要介绍了Python中super关键字用法,实例分析了super关键字的功能及相关使用技巧,需要的朋友可以参考下
  • 主要介绍了Java super关键字用法,结合具体案例形式分析了java super关键字调用父类构造方法、属性及方法等相关操作技巧与注意事项,需要的朋友可以参考下
  • 本文实例讲述了Python中super关键字用法。分享给大家供大家参考。具体分析如下:在Python类的方法(method)中,要调用父类的某个方法,在Python 2.2以前,通常的写法如代码段1:代码段1:class A:def __init__(self...

    本文实例讲述了Python中super关键字用法。分享给大家供大家参考。具体分析如下:

    在Python类的方法(method)中,要调用父类的某个方法,在Python 2.2以前,通常的写法如代码段1:

    代码段1:

    class A:

    def __init__(self):

    print "enter A"

    print "leave A"

    class B(A):

    def __init__(self):

    print "enter B"

    A.__init__(self)

    print "leave B"

    >>> b = B()

    enter B

    enter A

    leave A

    leave B

    即,使用非绑定的类方法(用类名来引用的方法),并在参数列表中,引入待绑定的对象(self),从而达到调用父类的目的。

    这样做的缺点是,当一个子类的父类发生变化时(如类B的父类由A变为C时),必须遍历整个类定义,把所有的通过非绑定的方法的类名全部替换过来,例如代码段2,

    代码段2:

    class B(C): # A --> C

    def __init__(self):

    print "enter B"

    C.__init__(self) # A --> C

    print "leave B"

    如果代码简单,这样的改动或许还可以接受。但如果代码量庞大,这样的修改可能是灾难性的。很容易导致修改错误的出现。

    因此,自Python 2.2开始,Python添加了一个关键字super,来解决这个问题。下面是Python 2.3的官方文档说明:

    super(type[, object-or-type])

    Return the superclass of type. If the second argument is omitted the super object

    returned is unbound. If the second argument is an object, isinstance(obj, type)

    must be true. If the second argument is a type, issubclass(type2, type) must be

    true. super() only works for new-style classes.

    A typical use for calling a cooperative superclass method is:

    class C(B):

    def meth(self, arg):

    super(C, self).meth(arg)

    New in version 2.2.

    从说明来看,可以把类B改写如代码段3:

    代码段3:

    class A(object): # A must be new-style class

    def __init__(self):

    print "enter A"

    print "leave A"

    class B(C): # A --> C

    def __init__(self):

    print "enter B"

    super(B, self).__init__()

    print "leave B"

    尝试执行上面同样的代码,结果一致,但修改的代码只有一处,把代码的维护量降到最低,是一个不错的用法。因此在我们的开发过程中,super关键字被大量使用,而且一直表现良好。

    1. super并不是一个函数,是一个类名,形如super(B, self)事实上调用了super类的初始化函数,产生了一个super对象;

    2. super类的初始化函数并没有做什么特殊的操作,只是简单记录了类类型和具体实例;

    3. super(B, self).func的调用并不是用于调用当前类的父类的func函数;

    4. Python的多继承类是通过mro的方式来保证各个父类的函数被逐一调用,而且保证每个父类函数只调用一次(如果每个类都使用super);

    5. 混用super类和非绑定的函数是一个危险行为,这可能导致应该调用的父类函数没有调用或者一个父类函数被调用多次。

    从super关键字的help我们也能看出来。

    Help on class super in module __builtin__:

    class super(object)

    | super(type) -> unbound super object

    | super(type, obj) -> bound super object; requires isinstance(obj, type)

    | super(type, type2) -> bound super object; requires issubclass(type2, type)

    | Typical use to call a cooperative superclass method:

    | class C(B):

    | def meth(self, arg):

    | super(C, self).meth(arg)

    |

    | Methods defined here:

    .......

    从上面也能看出来,super是一个类,而且是__builtin__模块中的。

    从上面的描述来看,super主要是用于调用父类的方法。

    那么,在2.2之前的方法也能调用。为啥非得用super呢?

    这是因为super能够阻止对父类方法的多次调用。

    super,改变了父类搜索顺序, 返回的是一个特殊的父类对象

    看例子:

    class A: pass class B(A): pass class C(A):pass class D(B, C): pass

    这是4个类的基本关系。

    假如不使用super,让D的对象调用他们共有的一个方法,会2次调用A中这个方法。

    希望本文所述对大家的Python程序设计有所帮助。

    展开全文
  • super关键字用法总结(无废话): 1.在子类的成员方法中,访问父类的成员变量。 2.在子类的成员方法中,访问父类的成员方法。 3.在子类的构造方法中,访问父类的构造方法。、 ` //父类 public class Fu{` int num =...

    super关键字用法总结(无废话):

    1.在子类的成员方法中,访问父类的成员变量。
    2.在子类的成员方法中,访问父类的成员方法。
    3.在子类的构造方法中,访问父类的构造方法。、

    `

    //父类
    public class Fu{`
              int num = 10;
              public void method(){
                      System.out.println("这是父类方法");                 
     }
    `}
    

    `

    //子类
    public class Zi extends Fu{
           int num = 20;
           public Zi(){
               super();
           }
        public void methodZi(){
           System.out.println(num);   //无super则访问子类的成员变量(20)
           System.out.println(super.num);//在子类中访问父类的成员变量num(10)
        }
        public void method(){
            super.method();   //访问父类中的method()方法
            System.out.println("这是子类方法");
        }
    }
    
    //测试类
    public class Test{
       public static void main(String[] args) {
            Fu f = new Fu();
            Zi z = new Zi();
            f.method();
            z.method();
        }
    }
    
    //结果
    父类构造方法
    父类构造方法
    这是父类方法
    这是父类方法
    这是子类方法
    
    展开全文
  • Java super关键字用法

    千次阅读 2015-03-20 14:02:15
    分别介绍了在构造方法和非构造方法super关键字的四种不同的用法

    构造方法中的super关键字

    在Java子类的构造方法中可以通过super关键字来调用父类的构造方法。其用法为:
    1) super(); 访问父类中的无参构造函数
    2) super (paras…); 访问父类中的成员函数yyy
    super()来调用父类无参的构造方法,但即使不使用super(),默认也会调用父类无参的构造方法。父类无参的构造方法可以是自定义的无参构造方法,也可以是编译器自动生成的默认构造方法。但如果父类中定义了有参的构造方法,但没有定义无参的构造方法,这时编译器不会生成默认构造函数,也就不能通过super()来调用构造方法。此外,如果父类中定义了private的无参构造方法,也不同通过super()来调用。
    super(paras…);用来调用父类中某个有参的构造方法。
    super调用父类的构造方法,必须放在子类构造方法的第一行中执行。如果调用的有参的父类构造方法,在super的参数中不能用子类中的非static成员变量(可以使用static成员变量,因为static成员变量在构造方法执行前就已经初始化),也不能使用this或super的相关调用。例如super(super.getClass().getName());
    在构造方法中也可以使用super关键字来访问父类中的成员变量和成员函数。其用法和非构造方法中的super关键字用法相同。

    非构造方法中的super关键字

    在Java子类中可以通过通过super关键字来调用父类中的成员变量和方法。其用法是。
    1) super.xxx; 访问父类中的成员变量xxx
    2) super.yyy(paras…); 访问父类中的成员函数yyy
    super关键字访问父类的成员变量和成员函数时不能越过访问权限的控制,不能访问父类中private的成员变量和方法。例如:

    class a {
        private int mNum = 0;
    }
    class b extends a {
        public void setNum(int i) {
            super.mNum = i;     //错误,不能访问父类的private成员
        }
    }

    在有多层的继承关系时,super调用只能自身父类的成员变量和方法,不能越过父类直接调用父类的父类中的成员变量或方法。当然如果父类的父类中的成员变量或方法被父类继承,那么是可以通过super来调用该成员变量和方法的,但这时实际调用的是父类中的成员变量和方法。例如:

    class a {
        protected int mNum = 0;
        public void setNum(int i) {
            mNum = i;
        }
    }
    class b extends a {
        public void setNum(int i) {
            mNum = i * i;
        }
    }
    class c extends b {
        public void setNum(int i) {
            super.setNum(i);        //调用的是b中的setNum()方法
            super.super.setNum(i);  //错误,不支持的用法
        }
    }
    class a {
        protected int mNum = 0;
        public void setNum(int i) {
            mNum = i;
        }
    }
    class b extends a {
    }
    class c extends b {
        public void setNum(int i) {
            super.setNum(i);    //正确,虽然b中没有实现setNum(),但b中继承了a的setNum()函数,
                                //c中调用super.setNum()调用的是b的setNum()函数,可以执行。
        }
    }
    展开全文
  • Java中super关键字用法

    2019-08-02 16:35:30
    super关键字主要用在子类继承父类时,咱们程序员在子类的方法里面想要调用父类的方法,变量时。在子类的main方法里面是不让用super、this的,因为main是static修饰的,static修饰的方法里面不让用这两个关键字。 1...

    super关键字主要用在子类继承父类时,咱们程序员在子类的方法里面想要调用父类的方法,变量时。在子类的main方法里面是不让用super、this的,因为main是static修饰的,static修饰的方法里面不让用这两个关键字。

    1、super.父类的变量

    注意,父类的变量如果是private修饰的不可被调用,而如果是public、protected、以及默认(就是没有加访问修饰符的)的访问修饰权限,则根据这三个访问修饰的访问权限而定。public肯定是可以被访问到的,protected的话就是不同包的非子类无法访问到,默认的就是只要在同包就可以,不同包就不行。

    2、super.父类的方法(参数列表)

    这个就是调用父类的方法,记得传参数以及它的访问权限和上面是一样的。

    3、super(参数列表),写在构造函数第一行!!!

    第三个方法是最重要的,super(参数列表),在子类的方法(一般是构造方法)里面调用父类的构造函数,并且编译器会根据你参数列表的不同,给你匹配对应的父类的构造方法,这句代码写在子类构造函数的第一行。一般当你用eclipse的自动生成构造函数时,它会自己给加这句代码。所以,咱们实例化子类的对象时,就会出现父类的构造函数先执行,然后才是子类的构造函数。

    注意这种情况:super(),调用父类的无参构造函数,而我们知道,当一个类没有人为的写明构造函数时,这个类会有一个默认的无参构造函数,当我们只要自己写了构造函数之后,这个默认的无参构造函数便会失效。这个概念在这里同样适用:当没有在构造函数里面写明super(参数列表)时,编译器会自动在第一行加上super(),用来调用父类的无参构造函数。如果我们写明super(参数列表),那么编译器就不加那句话了。

    展开全文
  • super关键字 在对象的内部sh
  • #this关键字使用方法代码分析 package basic.Filea; /** * this的介绍 * this是一个引用,this变量保存了内存地址指向自己 * 每一个对象都有一个this * this不能出现在static静态方法中 * 1.this的使用方法有...
  • 使用super关键字,会按照继承顺序执行相应类中的方法,在没有多继承的情况下,一般是执行父类 # -*- coding: utf-8 -*- #! /usr/bin/python class Counter(object): def __init__(self): super(Counter,self)._...
  • Java中this关键字和super关键字用法

    千次阅读 2017-08-25 10:32:59
    构造方法中的this关键字 构造方法是一个类的对象在通过new关键字创建时自动调用的,在程序中不能向调用其他方法一样通过方法名(也就是类名)来调用。但如果一个类有多个构造方法,可以在一个构造方法中通过this...
  • * super关键字用法有三种: * 1.在子类的成员方法中,访问父类的成员变量 * 2.在自类的成员方法中,访问父类的成员方法 * 3.在子类的构造方法中,访问父类的构造方法*/ public class Zi extends Fu{ int num=20; ...
  • 构造方法中的this关键字 构造方法是一个类的对象在通过new关键字创建时自动调用的,在程序中不能向调用其他方法一样通过方法名(也就是类名)来调用。但如果一个类有多个构造方法,可以在一个构造方法中通过this...
  • this 在java中,this是一个引用当前类对象的引用变量,主要有以下几种用法: 引用当前类的实例变量· this关键字可以用来引用当前类的...可以使用this关键字调用当前类的方法,格式:this.方法名。如果不使用t...
  • this在java中,this是一个引用当前类对象的引用变量,主要有以下几种用法:引用当前类的实例变量...调用当前类方法可以使用this关键字调用当前类的方法,格式:this.方法名。如果不使用this关键字,编译器会在调用方...
  • class A { constructor() { this.x = 1; } print() { console.log(this.x); } } ...class B extends A { ... super(); this.x = 2; } m() { super.print(); } } let b = new B(); b.m() // 2

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 161,632
精华内容 64,652
关键字:

super关键字的用法