标签: super

好吧,这将是一个非常令人尴尬的问题,但我在初学者的书中看起来很疯狂(特别是那些通常有用的指数)并且,我没有找到一个脚踏实地的解释'超级'在我的应用.

我在这看看这个,但我担心这远远超出我.任何人都可以提供一个非常简单的解释,说明我的应用程序中有什么"超级",以及为什么我应该成为它的朋友？例如:

- (void)viewDidLoad {
[super viewDidLoad];}

谢谢!!

这个问题只是让我感到困惑,在重写方法时很容易忘记调用super().

在我的情况下,我正在重构一些现有的东西,其中已经有大约十个类覆盖了一个方法.直到昨天,该方法都有一个空的默认实现,所以如果子类称为super,则无关紧要.你可以在任何有价值的IDE中找到覆盖物,但是你知道它是怎么回事,电话铃声,同事们背后都有一个小小的东西......很容易忘记检查一个地方或者忽略它.理想情况下,@ Override注释会有一个对应物,如果基类方法被注释但是覆盖不会调用super,编译器会为这些位置生成警告.

什么是我能做的最好的事情？

我在一本书中看到了一个关于java的例子:

public class A{
  public A(){
      System.out.println("A");
   }
}

public class B extends A{
    public B(){
       super();
       System.out.println("B");
   }

    public static void main(String[] args){
        B b = new B();
    }
}

我不明白为什么要super()在这里？即使我删除super(),我也会得到相同的结果(A将被打印,然后是B).据我所知,当我初始化子类时,父类在它之前初始化.为什么要使用super()？

如果我从一个类继承并且没有更改方法中的任何内容,是否需要使用super来从父类初始化该方法？

class A:

   def __init__(self):
       self.html = requests.get("example.com").text


class B(A):

    def __init__(self):
        # is this needed?
        super(B, self).__init__()

    def new_method(self):
        print self.html

class NewThread1 extends Thread{

    NewThread1(String name){

    super(name); //this line replaced by 'new Thread(name);'

    System.out.println("child Thread:"+this);

    }
}

public class ThreadCreationExtend {
   public static void main(String[] args) {
        new NewThread1("Thread1");
        new NewThread1("Thread2");
    }
}

output:child Thread:Thread[Thread1,5,main]
       child Thread:Thread[Thread2,5,main]

output after replacement: 
                          child Thread:Thread[Thread-0,5,main]
                          child Thread:Thread[Thread-1,5,main]

我正在尝试调用Thread类构造函数,Thread(String name)而不是使用super(name),但是当我使用新的Thread(String name)输出时会有所不同.请解释不同的输出.是因为默认的超级构造函数吗？如果是这样,那我如何使用没有super()的父构造函数Thread(String name)？

由于Javascript中还没有私有方法支持,我通常只是在类体外声明一个普通函数并提供this参数:

class Foo {
    constructor() {
        _doPrivateStuff(this);
    }
}

function _doPrivateStuff(that) {
    that.bar() // private stuff
}

export default Foo;

但是我怎么能以这种方式接受超级方法呢？

function _doPrivateStuff(that) {
    super.method(); // error, 'super' outside of function or class
}

除此之外,有一个很好的理由,为什么我不应该用这样的"私人"的功能呢？

顺便说一句,我只在Babel上试过这个,而使用_doPrivateStuff.bind(this)()而不是使用that也不起作用

要在Python 2.7中调用父类的构造函数,我看到的标准代码是:

super(Child, self).__init__(self, val),

Child儿童班在哪里.(在Python 3.x中,这是简化的,但我现在必须使用2.7.)我的问题是,在python 2.7中使用super的"规范"不是更好:

super(self.__class__, self).__init__(self, val)？

我测试了这个,它似乎工作.有没有理由不使用这种方法？

我正在尝试学习和理解如何在Python中使用super，我一直在遵循《从新手到专家的Python历程》一书，尽管我觉得我理解概念“在我自己的代码中执行super存在问题”。

例如，此方法对我有用：

class Employee:        
    def __init__(self, firstname, lastname, age, sex, dob):
        self.firstname = firstname
        self.lastname = lastname
        self.age = age 
        self.sex = sex
        self.dob = dob
        self.all_staff.append(self)

class Hourly(Employee):
    def __init__(self, firstname, lastname, age, sex, dob, rate, hours):
        self.rate = rate
        self.hours = hours
        super().__init__(firstname, lastname, age, sex, dob)

    def __str__(self):
    return "{} {}\nAge: {}\nSex: {}\nDOB: {}\n".format(self.firstname, self.lastname, self.age, 
        self.sex, self.dob)

    def get_rate(self):
        print('The hourly rate of {} is {} '.format(self.firstname, self.rate))

hourlystaff1 = Hourly('Bob', 'Foo', '23', 'M', '12/1/1980', '$15', …

我目前有一个类,让我们称之为Person,使用类似的构造函数.

public class Person
{
    private String name;

    public Person(String name)
    {
        this.name = name;
        System.out.println("This person is: "+getName());
    }

    public String getName()
    {
        return this.name;
    }

    public void setName(String name)
    {
        this.name = name;
    }
}

然后我们使用更具体的Person类继承该类,在本例中为Employee.

public class Employee extends Person
{
    private int id;

    public Employee(String name, int id)
    {
        super(name);
        this.id = id;
        System.out.println("This person is: "+getName()+", identified by #"+getId());
    }

    public int getId()
    {
        return this.name;
    }

    public void setId(int id)
    {
        this.id = id; …

我遇到的问题是我有一些基类（泛型），它们的属性是通过类的构造函数初始化的。然后，当我扩展该类以创建一个更特定的类时，必须重新键入与基类的构造函数相同的参数，以便将它们传递给super。如果您想象一个非常通用的类，它具有许多通过构造函数初始化的属性，并且经常扩展，那么每次必须不断重新键入所有这些属性以将它们传递给super似乎效率很低。我可能会缺少一些防止这种情况的常见方法。有什么想法可以提高效率吗？也许通过某种方式“继承”父类的构造函数参数？

下面是一个代码示例，并且，你可以看到，在Programmer类的构造函数，我必须重新输入name，age以及height再次仅仅将其传递到super：

class Person {
    name: string;
    age: number;
    height: number;

    constructor(name: string, age: number, height: number) {
        this.name = name;
        this.age = age;
        this.height = height;
    }
}

class Programmer extends Person {
    languages: string[];

    constructor(name: string, age: number, height: number, languages: string[]) {
        super(name, age, height);

        this.languages = languages;
    }
}