标签: super

在Java类型参数中,是否仅表示严格的子类型？还是E也足够了？

实际定义"超级"的地方？[当我们使用super.someMethod()]时.它被定义为java.lang.Object类或java.lang.Class类中的字段吗？

当我们从子类调用时,super包含对它的超类的引用.以同样的方式,超类本身的超级引用它的超类[以这种方式upto java.lang.Object].那么,java如何将超类引用注入"超级"字段,这使我们能够调用超类方法？

有没有像下面这样的引擎实现:

    Class current = this.getClass();
    Class parent = current.getSuperclass();
    System.out.println("name is =" + parent);

是否有维持在需要传递一些扩展类(比使它从超类访问,或将其传递到构造函数中的参数等)的超级构造函数构造函数创建的对象的引用的好办法？

让我用一个例子来澄清.拿这个类(我无法修改,哪些不能让我访问foo):

class TestA {
    TestA(Object foo) {}
}

现在,我想扩展这个类如下:

class TestB extends TestA {
    Object myCopyOfFoo;

    TestB() {
        super(new Object());
    }
}

有没有一种很好的方法来存储创建new Object()的myCopyOfFoo？

这三个想法中的任何一个都不起作用:

TestB() {
    myCopyOfFoo = new Object();
    super(myCopyOfFoo);
}

(错误:构造函数调用必须是构造函数中的第一个语句)

TestB() {
    super(myCopyOfFoo = new Object());
}

(错误:显式调用构造函数时无法引用实例字段myCopyOfFoo)

TestB() {
    super(makeFoo());
}

Object makeFoo() {
    myCopyOfFoo = new Object();
    return myCopyOfFoo;
}

(错误:显式调用构造函数时无法引用实例方法)

我想我可以做到以下几点,但它既不是线程安全也不优雅:

static Object tempFoo;

TestB() {
    super(tempFoo = new Object());
    myCopyOfFoo = tempFoo;
}

有没有人对我有更好的想法？为什么我的前两个想法不合法呢？

我有一个案例,我的类有一个自定义元类,在创建它时调用类的类方法,如:

class Metaclass(type):
    def __new__(cls, name, bases, attrs):
        ...
        new_class = super(Metaclass, cls).__new__(cls, name, bases, attrs)
        ...
        new_class.get_fields() # do something
        ...
        return new_class

class FooBar(object):
    __metaclass__ = Metaclass

    @classmethod
    def get_fields(cls):
        ...

(此类代码的示例在Tastypie中.)

问题是如果我想这样做:

class NewBar(FooBar):
    @classmethod
    def get_fields(cls):
        super(NewBar, cls).get_fields()
        ...

这不起作用,因为NewBar尚未在super调用点创建(程序流仍在元类中).那么,有没有解决方法？

我知道可能get_fields方法可能成为元类的方法,但是这会使继承更难实现(你必须定义新的元类和类本身,对于想要扩展这个类的开发人员来说并不好).

(Python 2.7.)

首先,我想说我正在使用遗留代码,无论我想要多少,我都无法改变它.

顺便说一句,我要做的是验证是否调用了super.method().这是我试图用Mockito/Junit测试的具体内容:

class foo extends JApplet(){

       public void destroy(){
          super.destroy();
 }
}

通常情况下,如果这不是一个被调用的超级方法,那么在测试用例中就足够了:

verify(foo).destroy();

我已经看过几次问这个问题,通常回答是"继承是坏的,改变你的代码",遗憾的是我完全不能做.是否有人知道我可以做的任何框架或小小技巧来测试这个？

提前谢谢 - 我知道这是一个棘手的问题!

(在谷歌搜索之后,我无法在任何地方找到参考资料.)

可以使用以下简短代码示例清楚地演示该场景:

class X:
    def __init__(self, stuff):
        self.__stuff = stuff

class Y(X):
    def __init__(self, stuff):
        # Is it safe to execute statements before calling super.__init__()?
        new_stuff = self.call_another_method(stuff)
        super(Y, self).__init__(new_stuff)

使用CPython 3.x,上面的代码示例有效 - 假设call_another_method()存在.这种编码风格通常是安全的,但不赞成或被认为是unPythonic？我无法就此事找到建议.

我为什么在意？

我的背景来自更传统的面向对象编程语言,如C++,C#和Java,其中"super"必须严格地作为子类构造函数中的第一个语句调用 - 忽略零参数,隐式情况.

如果重要的话,我年轻的Pythoneer:3+,拜托.

python 中内置函数的一个用例super()是调用重写的方法。super()这是一个使用调用Parent类函数的简单示例echo：

class Parent():
    def echo(self):
        print("in Parent")

class Child(Parent):
    def echo(self):
        super().echo()
        print("in Child")

我见过将 2 个参数传递给super(). 在这种情况下，签名看起来有点像子类从super(subClass, instance)哪里调用，并且是调用的实例，即。因此，在上面的示例中，该行将变为：subClasssuper()instanceselfsuper()

super(Child, self).echo()

查看python3 文档，从类内部调用时，这两个用例是相同的。

super()从 python3 开始，使用 2 个参数的调用是否已完全弃用？如果这仅在调用重写函数时被弃用，您能否举例说明为什么其他情况需要它们？

我也有兴趣知道为什么 python 需要这两个参数？在 python3 中进行调用时是否会注入/评估它们super()，或者在这种情况下不需要它们？

我对 Flutter 和 Dart 还很陌生，并且在理解如何重写扩展 Equatable 更新版本的类时遇到了一些困难。

这适用于 Equatable 0.4.0：

abstract class Failure extends Equatable {
   Failure([List properties = const<dynamic>[]]) : super(properties);
}

但是，更新到 Equatable 1.0.2 会引发错误super(properties)：

位置参数太多：预期有 0​​ 个，但找到了 1 个。

尝试删除额外的参数。

我不明白如何使用 Equatable 1.0.2 传递properties给超级构造函数

假设我有一个用于添加/编辑产品的表单(字段'user'是我的用户的外键),它是从两个单独的视图函数触发的 - 添加/编辑:

def product_add(request):
    userprofile = UserProfile.objects.get(user=request.user)
    if request.method == 'POST':
        form = ProductAddForm(request.POST, request.FILES,)
        if form.is_valid():
            form.save(user=request.user)
    else:
        form = ProductAddForm()
    return render_to_response('products/product_add.html', {
            'form':form, 'user':request.user,
            }, context_instance=RequestContext(request))

def product_edit(request, id):
    product = get_object_or_404(Product, id=id, user=request.user)
    if product.user.id!=request.user.id:
        raise Http404
    if request.method == 'POST':
        form = ProductAddForm(request.POST, request.FILES, instance=product)
        if form.is_valid():
            form.save(user=request.user)            
    else:
        form = ProductAddForm(instance=product)
    return render_to_response('products/product_edit.html', {
            'form':form, 'user':request.user,
            }, context_instance=RequestContext(request))

表单的save方法如下所示:

def save(self, user, *args, **kwargs):
    self.instance.user = user                           
    post = super(ProductAddForm, self).save(*args, **kwargs)
    post.save() …

在调查这个问题时,我遇到了单一参数的奇怪行为super:

调用super(some_class).__init__()在some_class(或其子类)的方法内部工作,但在其他地方调用时抛出异常.

代码示例:

class A():                                                                                         
    def __init__(self):                                                         
        super(A).__init__()  # doesn't throw exception

a = A()
super(A).__init__()  # throws exception

抛出的异常是

Traceback (most recent call last):
  File "untitled.py", line 8, in <module>
    super(A).__init__() # throws exception
RuntimeError: super(): no arguments

我不明白为什么电话的位置有所不同.

众所周知,super 执行魔法的零参数形式:

零参数形式仅适用于类定义,因为编译器填写必要的细节以正确检索正在定义的类,以及访问普通方法的当前实例.

但是,对于单参数形式,没有这样的陈述super.反之:

另请注意,除零参数形式外,super()不限于使用内部方法.

所以,我的问题是,引擎盖下究竟发生了什么？这是预期的行为吗？