标签: super

我正在阅读如何在Objective-C中实现私有方法(在Objective-C中为类定义私有方法的最佳方法)以及我脑海中浮现的一个问题:

您如何设法实现受保护的方法,即子类可见的私有方法？

假设我有一个MySuperClass,其中包含一个包含其所有私有方法的Category,我想实现一个MySubclass覆盖或调用super到其中一个MySuperClass私有方法.这是可能的(使用Categories方法实现私有方法)？

看一下这些代码,底部有覆盖方法.

// ===========================
// = File: MySuperClass.h
// = Interface for MySuperClass
// ===========================

@interface MySuperClass : Object
...
@end

// ===========================
// = File: MySuperClass.m
// ===========================
#import "MySuperClass.h"

// =================================
// = Interface for Private methods
// =================================
@interface MySuperClass (Private)

-(void) privateInstanceMethod; 

@end

// =====================================
// = Implementation of Private methods
// =====================================
@implementation MySuperClass (Private)

-(void) privateInstanceMethod
{
  //Do something
}

@end

// ================================
// = Implementation for MySuperClass
// ================================ …

我有3个Django模板:

base.html文件

<title>{% block title %} SITE NAME {% endblock %}</title>

default.html中

{% extends "base.html" %}
{% block title %} {{ block.super }} - SECTION NAME {% endblock %}

main.html中

{% extends "default.html" %}
{% block title %} {{ block.super }} {% endblock %}

我想在模板main.html中获取SITE NAME,即父块的父级内容.就像是

{{ block.super.super }}

这可能吗？

这是我正在经历的django教程中的一些代码.我之前从未遇到过python中的超级函数,它在这里使用的方式与我在网上看到的例子不同.即,通常当你使用超级时,你不是有多个班级吗？它在最后一行: super(Snippet, self).save(force_insert, force_update) 你能解释一下那里发生了什么,以及另一种写作方式.看起来似乎save方法在这里调用自己？

class Snippet(models.Model):
    title = models.CharField(max_length=255)
    language = models.ForeignKey(Language)
    author = models.ForeignKey(User)
    description = models.TextField()
    description_html = models.TextField(editable=False)
    code = models.TextField()
    highlighted_code = models.TextField(editable=False)
    tags = TagField()
    pub_date = models.DateTimeField(editable=False)
    updated_date = models.DateTimeField(editable=False)

    class Meta:
        ordering = ['-pub_date']

    def __unicode__(self):
        return self.title

    def save(self, force_insert=False, force_update=False):
        if not self.id:
            self.pub_date = datetime.datetime.now()
        self.updated_date = datetime.datetime.now()
        self.description_html = markdown(self.description)
        self.highlighted_code = self.highlight()
        super(Snippet, self).save(force_insert, force_update)

我说的是java语言.

变量"this"在类中使用时,引用该类的当前实例,这意味着您不能在静态方法中使用"this".

但是"super",当在类中使用时,指的是该类的超类,而不是超类的实例,这应该意味着你可以在静态方法中使用"super".但事实证明你做不到.

一个可能的解释是说"超级"也指超类的一个实例,但我不明白为什么它应该......

当我在java类中编写构造函数时,我通常不会在那里调用super().当我从eclipse源代码编辑器生成构造函数时,为什么它总是在那里添加super()？

我没有在我编写的构造函数中默认添加它是错误的吗？如果我决定使用eclipse代码生成器,那么在构造函数中抛出super()调用会有什么问题吗？

好的,所以我觉得我得到了超级does独立的东西.基本上在Devise中,if Users::RegistrationsController < Devise::RegistrationsController,然后在任何动作上,有一个super遗嘱首先在父亲中Devise::RegistrationsController调用同一个命名动作的逻辑,然后再调用你所写的内容.

换一种说法...

class Devise::RegistrationsController
  def new
    puts "this is in the parent controller"
  end
end

class Users::RegistrationsController < Devise::RegistrationsController
  def new
    super
    puts "this is in the child controller"
  end
end

# Output if users#new is run would be:
# => "this is in the parent controller"
# => "this is in the child controller"

# If super were reversed, and the code looked like this
# class Users::RegistrationsController < …

我试图save()从子实例调用super方法.

// ImageKeeper.js
'use strict';

module.exports = class ImageKeeper extends FileKeeper {
  constructor(keeperPath, options) {
    super(`/${keeperPath}`, options)
    this.keeperPath = keeperPath;
  }

  save(filePath) {
    return new Promise((resolve, reject) => {
      this
        .resolvePath(filePath)
        .then(function(fileData) {
          var filePath = fileData[0],
            mime = fileData[1];

          super.save(filePath, mime); // <-- GETTING ERROR HERE
        })
        .catch(function(err) {
          reject(err)
        })
    })
  }
}

// FileKeeper.js
'use strict';

module.exports = class FileKeeper {
  constructor(keeperPath, options) {
    this.storagePath = path.resolve(`${env.paths.storage}${keeperPath}`);
    this.options = options;
  }

  save(filePath, mime) {
    return …

我意识到super关键字可用于调用父组件中的函数.但是,我不完全清楚为什么你会在下面的例子中使用super关键字 - 只是传递它传递给构造函数的任何道具.

请问有人可以了解在ES6类构造函数中使用super关键字的各种原因吗？

  constructor(props) {
    super(props);

    this.state = {
      course: Object.assign({}, this.props.course),
      errors: {   }
    };

    this.updateCourseState = this.updateCourseState.bind(this);
  }

当我尝试覆盖魔术方法__eq__,并使用super访问找到的基本方法时object,我收到一个错误.这不是一个错误,但它确实感觉像一个:

class A(object):
    def __eq__(self, other):
        return super(A, self).__eq__(other)
A() == 0

# raises AttributeError: 'super' object has no attribute '__eq__'

这是不直观的,因为object.__eq__存在,但class A(object): pass它没有.如果我没有错误__eq__地进行is检查,那么这可能是解决方法,但使用is而super不是mixin友好.在我的情况下,这条路线是可以的,但在其他情况下可能不是.

任何建议,或关于为什么这样__eq__工作的信息都会很棒.

我的代码在 Python 3.6 中运行，但在 Python 3.8 中失败。似乎归结为调用super的子类typing.NamedTuple，如下所示：

<ipython-input-2-fea20b0178f3> in <module>
----> 1 class Test(typing.NamedTuple):
      2     a: int
      3     b: float
      4     def __repr__(self):
      5         return super(object, self).__repr__()

RuntimeError: __class__ not set defining 'Test' as <class '__main__.Test'>. Was __classcell__ propagated to type.__new__?

In [3]: class Test(typing.NamedTuple): 
   ...:     a: int 
   ...:     b: float 
   ...:     #def __repr__(self): 
   ...:     #    return super(object, self).__repr__() 
   ...:                                                                         

>>> # works

此super(object, self).__repr__调用的目的是使用标准'<__main__.Test object at 0x7fa109953cf8>' __repr__而不是打印出元组元素的所有内容（默认情况下会发生这种情况）。有一些 关于导致类似错误的问题 …