在父类本身中使用了'super()‘，为什么？
在父类本身中使用'super()'是为了调用父类的构造函数。在面向对象编程中，子类继承了父类的属性和方法，但是子类也可以有自己的属性和方法。当子类需要初始化自己的属性时，通常需要先调用父类的构造函数来完成父类属性的初始化工作。
使用'super()'可以确保在子类中调用父类的构造函数，从而完成父类属性的初始化。这样可以避免重复编写相同的初始化代码，提高代码的复用性和可维护性。
'super()'的使用还可以保证在多层继承关系中，父类的构造函数按照正确的顺序被调用。这样可以确保父类的属性被正确地初始化，避免潜在的错误和逻辑混乱。
在使用'super()'时，需要注意的是，如果子类定义了自己的构造函数，则必须在构造函数中显式地调用'super()'，否则父类的构造函数不会被执行。如果子类没有定义构造函数，则会自动调用父类的构造函数。
总之，使用'super()'可以确保子类在初始化自己的属性时，正确地调用父类的构造函数，保证继承关系的正确性和代码的可维护性。
相关·内容
我正在学习React.js，我看到super关键字在构造函数中使用了很多。
我知道super允许子类访问this关键字。然而，我找不到更多的解释。
为什么调用super()，神奇地使我的类访问this
为什么super关键字将this绑定到类的上下文？
当我不处理子类时，为什么不调用super()
浏览 5提问于2017-02-01得票数 13
1回答
如何在超类中使用私有实例变量？
、、、、
我目前正在学习java类中的继承。我不明白为什么我不能在我的子类中使用变量"ID“。我的savings类的构造函数有什么问题？另外，我不允许将account中的实例变量更改为public。
public class Account
{
private String ID;
private double balance;
private int deposits;
private int withdrawals;
private double service;
/**
* Constructor for objects of class Account
*/
public
浏览 0提问于2017-05-15得票数 1
3回答
我有3个类A，B和D，如下所示
class A(object):
def test(self):
print "called A"
class B(object):
def test(self):
print "called B"
class D(A,B):
def test(self):
super(A,self).test()
inst_d=D()
inst_d.test()
----------------------------------------
Output:
c
浏览 0提问于2012-07-19得票数 5
我有以下代码：
class A:
def __init__(self):
print("A.__init__")
class B(A):
def __init__(self):
print("B.__init__")
super().__init__()
class C(A):
def __init__(self):
print("C.__init__")
super().__init__()
class D(B,C):
def
浏览 0提问于2016-09-10得票数 0
我希望这不是重复，因为我没有找到答案。只引用c++析构函数，但我对此一无所知。无论如何，我习惯于在我自己的芽上覆盖我的方法，以加快进程，我现在开始使用to源代码重写/实现方法，我不明白为什么eclipse会自动粘贴。
super.method(event);
在我的代码中，为什么eclipse会为我做这个？它真的做了什么吗?无论如何，我已经调用了该方法，为什么它必须出现两次，我不明白。我的意思是：
someJlabel.addMouseListener(new MouseAdapter() {
@Override
public void mouseE
浏览 2提问于2014-01-03得票数 0
回答已采纳
3回答
实际上，我们知道super用于查找“父类”并返回其对象，类似于/使用self.__class__.__mro__
我困惑的是什么时候才能准确地使用它？
假设我们有一个示例模型代码，如下所示
version_1
class Example(models.Model):
name = models.CharField()
age = models.IntegerField()
def save(self, **args, **kwargs):
obj = super(Example, self).save(self, **args, **kwargs)
浏览 3提问于2013-10-05得票数 6
回答已采纳
2回答
据我所知，super()用于调用子类中覆盖的方法(就像子类中的覆盖__init__ )。
而且，我知道所有python类都是从一个名为object的特殊类继承的。
在研究OOP时，我遇到了一个奇怪的例子：
class A(object):
def __init__(self):
print('A.__init__')
super().__init__()
class B(object):
def __init__(self):
print('B.__init__')
super()
浏览 8提问于2020-01-21得票数 1
回答已采纳
我经常看到这样的代码：
class MyClass{
private int a;
public MyClass(int a){
super(); //what is the purpose of this method call?
this.a = a;
}
//other class methods here
}
如果类扩展对象，super()调用对象构造函数，据我所知，该构造函数什么也不做。那么为什么需要调用super()呢？我对这种特殊情况很感兴趣，因为超级()只调用了Object
浏览 4提问于2016-12-11得票数 2
回答已采纳
我在react中是新的，我注意到我们使用this.setState()而不是super.setState()，我需要清楚地解释为什么我们使用这个来调用超类方法？例子：
class Checkbox extends React.Component {
constructor(props) {
super(props)
this.state = {
checked: true
}
this.handleCheck = this.handleCheck.bi
浏览 1提问于2018-04-07得票数 3
回答已采纳
1回答
来自
# Declare both screens
class MenuScreen(Screen):
pass
class SettingsScreen(Screen):
pass
从这个
class WelcomeScreen(Screen):
def __init__(self, **kwargs):
super(Screen,self).__init__(**kwargs)
在何种情况下需要使用super初始化屏幕，为什么？
浏览 1提问于2016-10-31得票数 8
回答已采纳
class Base{
constructor(val){
this.val = val;
}
basep = 'default1';
basef(){
return 2;
}
}
class Test1 extends Base{
constructor(val,name){
super(val);
this.name=name;
}
getp(){
console.log(this.name,this.val
浏览 26提问于2020-10-19得票数 0
我有以下代码：
class Bike
attr_reader :chain
def initialize
@chain = default_chain
end
def default_chain
raise 'SomeError'
end
end
class MountainBike < Bike
def initialize
super
end
def default_chain
4
end
end
mb = MountainBike.new
p mb.chain
当我们在初始化过程中调用
浏览 2提问于2014-02-10得票数 0
有什么区别：
class Child(SomeBaseClass):
def __init__(self):
super(Child, self).__init__()
和：
class Child(SomeBaseClass):
def __init__(self):
SomeBaseClass.__init__(self)
我已经看到super在只有单一继承的类中使用了很多。我可以看到为什么你会用它来进行多重继承，但是我不清楚在这种情况下使用它的好处
浏览 504提问于2017-12-26
2回答
我很困惑
super.i = j+1；
这行代码。我认为它只改变了A类中的变量I，而不改变B类中继承的变量I。
为了明确这个问题，我添加了另一个示例(示例2)。在示例2中，我们使用
超级(平衡，名称)；
初始化从父类继承的属性。当我们调用Super并更改变量余额和名称时，我们不会更改父类中的变量余额和名称。
在示例1中，我们使用
super.i = j+1；
我们实际上更改了父类中的变量i，而不是从父类继承的变量。这两个样品有什么区别？非常感谢。
编辑2019年7月18日
我在示例2中添加了一个diriver类，在CheckingAccount中创建对象c之后，c中的
浏览 2提问于2019-07-18得票数 0
回答已采纳
我有一个基类和一个子类。在基类中，我有一个在__init__中调用的实例方法。在子类中，我重写了此方法。子类中的super()调用不调用原始基方法，而是调用重写的子类方法。为什么？
class BaseClass:
def __init__(self, value):
self.value = value
self.transformed_value = self.create_value(value)
def create_value(self, value):
print("base")
浏览 1提问于2019-07-15得票数 5
回答已采纳
如果构造函数没有在Java中继承，为什么我会得到编译错误(默认构造函数不可见的隐式超级构造函数A() )。必须定义显式构造函数)？
class A {
private A() {
}
}
public class B extends A {
}
UPD。我知道在隐式B构造函数中调用super()。但是我不明白为什么它不能用super()访问私有构造函数。所以，如果我们只有私有构造函数，那么类事实上就是final。
浏览 0提问于2015-07-03得票数 5
回答已采纳
我有一个代码片段，我应该确定我应该取消注释的行，这样它就会编译。
问题：为什么只有第9行、第13行和第10行第14行工作？例如，为什么9,14不起作用？我有点糊涂。(顺便说一句，这些选项只有注释两行代码)。
1. // Question 3.1
2. class Car {
3. private Car() { }
4. protected Car(int x) { }
5. }
6. public class MG extends Car {
7. // MG(int x) { }
8. // MG(int x) { super(); }
9. // MG(int x) {
浏览 4提问于2017-05-28得票数 1
回答已采纳
2回答
我和一些高级JavaScript人员一起工作，他们在代码中使用了SUPER关键字。我承认，我不能很好地掌握一个人如何以及为什么要使用它。
有人能指导我或告诉我如何精通它的用法和推理吗？
下面是一些示例：
openup: function( $super ) {
$super();
this.shop.enable_access();
}
addLeft: function( data ) {
var cell = Element('td');
if ( data.item_data ) {
var item = new SR
浏览 0提问于2012-01-07得票数 2
在由发布的reactjs.org中，有人指出“类组件应该始终使用props调用基本构造函数”。据super(props)说，在我自己的研究中，如果this.props不在构造函数中使用，那么this.props似乎可以被this.props取代。
因此，我的问题是，为什么我们总是将props传递给reactjs中的基本构造函数？这个建议听起来不错吗？为什么建议是健全的(或不健全)？
一个屏幕截图被上传到这个问题上，以防当这个问题被回答时，原来的教程被更新。
浏览 1提问于2019-01-30得票数 11
回答已采纳
1回答
因此，我使用这些类来处理不同场景中的错误，如下所示：
export class APIError extends Error {
public readonly statusCode: number;
public readonly message: string;
constructor(statusCode?: number, message?: string) {
super(message);
Object.setPrototypeOf(this, APIError.prototype);
if (typeof
浏览 4提问于2022-01-31得票数 1
回答已采纳
4回答
我有以下的类，它不编译：
public class C {
public String toString() {
return "Test " + super;
}
}
给出了编译错误Syntax error on token "super", invalid Expression。
有人知道为什么会发生这个编译器错误吗？预期的效果将是"Test " + super.toString()，它编译得很好，但是为什么上面的示例无法编译呢？这里不应该适用用于字符串级联的普通Java规则吗？
更令人惊讶的是，以下代码编译得
浏览 2提问于2019-05-01得票数 0
回答已采纳
我有一个屏幕'About‘，它不需要tabBar，但该屏幕的其他兄弟必须有tabBar。
标签中名为“Settings”的第三个元素有一个默认类，我在该类中使用了堆栈导航器。
export default class Setting extends Component {
constructor(props) {
super(props);
this.state = {
}
}
static navigationOptions = {
header: null,
tabBarVisi
浏览 7提问于2018-02-08得票数 0
回答已采纳
我试图理解对JDK所做的更改：
在此更改之前，使用了双重检查锁定来确保线程安全，这会导致问题。
他们为什么要使用另一个子类呢？为什么他们不简单地在StrictMath中使用StrictMath
或者，更笼统地说，为什么会这样：
标准技术是有一个嵌套子类，并在需要时初始化最后一个字段(懒惰)
(来自)
浏览 0提问于2016-04-08得票数 3
回答已采纳
class Animal(object):
def eat(self):
print("I eat all")
class C(object):
def eat(self):
print("I too eat")
class Wolf(C, Animal):
def eat(self):
print("I am Non Veg")
super(Wolf, self).eat()
Animal.eat(self)
w = Wolf()
w.
浏览 3提问于2011-09-14得票数 11
回答已采纳
由于Javascript中还没有私有方法支持，所以我通常只是在类主体之外声明一个正常函数，并提供this作为参数：
class Foo {
constructor() {
_doPrivateStuff(this);
}
}
function _doPrivateStuff(that) {
that.bar() // private stuff
}
export default Foo;
但我如何才能以这种方式访问super.method呢？
function _doPrivateStuff(that) {
super.method(); /
浏览 3提问于2016-08-31得票数 2
回答已采纳
我知道必须调用超类的指定初始化器，我想init(type: UIButtonType)已经调用了指定的初始化器，所以我在子类中使用了方便的初始化器，但失败了
class TSContourButton: UIButton {
enum ContourButtonSizeType {
case large
case small
}
convenience init(type:ContourButtonSizeType) {
self.init(type: .custom)
}
然后，我尝试了这个。它编译得很好。但是，它看起来并不专业
class TSClass: UIB
浏览 5提问于2017-01-04得票数 1
我对JS很陌生，正在学习课程和继承，但我面临着为什么要在子类中使用超级方法的困惑。以下是代码：
class Animal {
constructor(name, weight) {
this.name = name;
this.weight = weight;
}
eat() {
return `${this.name} is eating!`;
}
sleep() {
return `$
浏览 0提问于2019-08-12得票数 1
回答已采纳
1回答
在处理数据库时，我注意到了一些事情，特别是处理数据库的python ORMs。
下面是django中的save()函数的一个示例：
def save(self, **kwargs):
self.somevar = dosomething(self.someothervar)
return super(<Your_Model_Here>, self).save()
在谷歌应用引擎中，也使用了函数put()：
def put(self, **kwargs):
self.<some_var> = doSomething(self.someOtherVa
浏览 2提问于2013-06-22得票数 0
回答已采纳
在从onPostExecute中重写AsyncTask之类的方法时，我们可以避免或从其中删除super.onPostExecute(result);。你能告诉我为什么和什么时候需要用这个电话吗？因为我在这里实现了AsyncTask作为一个内部类在我的主要活动
private class CustomAsyncTask extends AsyncTask<String, Void, Event> {
@Override
protected Event doInBackground(String... strings) {
Event resul
浏览 8提问于2020-08-15得票数 2
回答已采纳
-(void)viewWillAppear:(BOOL)animated{
//something here
[super viewWillAppear];
}
总是需要[super viewWillAppear];吗？如果不是，你什么时候使用它，为什么使用它？
浏览 2提问于2010-07-28得票数 30
回答已采纳
开门见山，在基于react类的组件中，prop对象从何而来？
我正在遵循官方的React tic-tac-toe游戏教程。
首先，当我查看react Component类(我们在创建React组件时对其进行扩展)的代码时，我观察到该函数有3个参数Component(props, context, updater)，但我不明白为什么在调用props ()的情况下只像super(props)这样传递props。不是也应该为context和updater传递值吗？为什么代码在不调用super的情况下运行时没有错误？
import React, { Component } from "reac
浏览 0提问于2019-06-23得票数 2
我只是在玩Python MRO，发现了一些关于多继承的奇怪的东西。代码：
class A():
def __init__(self):
print('enter A')
print('leave A')
class B(A):
def __init__(self):
print('enter B')
super().__init__()
print('leave B')
class C():
def __init_
浏览 1提问于2019-11-05得票数 0
2回答
class One:
def __init__(self):
self.one = 1
class Two:
def __init__(self):
self.two = 2
class Three(One, Two):
def __init__(self):
self.three = 3
super().__init__()
obj = Three()
print(obj.one)
print(obj.two)
print(obj.three)
我目前正在自学OOP，我很难理解为什么对象能够
浏览 3提问于2022-10-26得票数 2
这是我拥有的示例html。
<ul id="alist">
<li class="red">...</li>
<li class="blue">...</li>
<li class="red">...</li>
<li class="green">...</li>
</ul>
目的:选择列表中所有没有“red”类的元素，并将它们淡出。
这就是我到目前为止所拥有的。我知道这很接近，但要么是代码中有b
浏览 1提问于2011-05-18得票数 1
回答已采纳
我的问题是，在基类中编写Super.toString()的原因是什么，它返回什么，为什么？
这是我的代码：
class Person {
public String toString() {
return super.toString() /*+ "->" + "Person" + name + "------"*/;
}
}
应该返回的是什么？谢谢，我是java的初学者。
浏览 3提问于2015-08-10得票数 1
回答已采纳
2回答
我在这里问这个问题是因为我真的不知道我该怎么搜索这个。我需要确认一下我今天可能想出来的一些事情。几天前，我曾想过，如果一个对象继承了其父方法，这意味着它的代码中基本上“有”该方法。但后来我问如果我们这样做
class B extends A {
public B() {
}
public int getValue() {
return 2 * super.getValue();
}
}
class C extends B {
public C() {
}
public int getValue(int b) {
return 5 *
浏览 0提问于2014-08-26得票数 2
回答已采纳
1回答
调用父类函数
、、
这是我第一次尝试使用super()，我尝试了对这段代码进行许多小的修改，但是我在super()所在的在线上得到了所有的错误。
我看到了类似的问题，但他们没有在我的情况下工作，或者我做错了什么。
你能帮我从list()打电话给list()吗？
class Gmail:
def getMessagesBodies(self, text):
return self.unpackPayload(text)
def unpackPayload(self, text):
return (text)
class getMessages:
浏览 0提问于2018-11-02得票数 0
回答已采纳
我有一个这样的代码：
class sampleClass(object):
def __init__(self):
super(sampleClass, self).__init__()
我的问题是，为什么它在__init__下自称超级？
我知道super是用来调用父类的__init__的(如果我错了，请告诉我)，但是它在这里做什么呢？
浏览 9提问于2017-02-12得票数 3
家长班：
public class Parent {
public void run()
{
walk();
System.out.println("Parent run");
}
public void walk()
{
System.out.println("Parent walk");
}
儿童班：
public class Child extends Parent {
public void run()
{
super.run();
System.out.println("child run")
浏览 12提问于2020-06-14得票数 1
3回答
所以在python中，为了调用子类中的父类函数，我们使用了super()方法，但是为什么我们使用super()，当我们只需要调用父类函数时，假设我有一个Class Employee:，并且我有另一个继承自Employee类class Programmer(Employee):的类来调用程序员类中的Employee类的任何函数，我可以只使用Employee.functionName()来完成这项工作。以下是一些代码：
class Person:
country = "India"
def takeBreath(self):
print("
浏览 4提问于2021-06-16得票数 0
回答已采纳
我在用遗产。在我的方法中，我想同时使用父属性和over子属性。类似的东西；
class Parent(object):
att = 'parent'
def my_meth(self):
return super().att + self.att
class Child(Parent):
att = 'child'
print(Child().my_meth())
打印出来的；
亲子
然而，上面的代码给出了错误；
“超级”对象没有属性“选项”
这个是可能的吗？
浏览 0提问于2018-12-06得票数 2
回答已采纳
在集合视图中，我在类init时创建一个手势识别器。在viewDidLoad方法中，我将手势识别器添加到集合视图中。
class ViewController: UIViewController {
@IBOutlet weak var collectionView: UICollectionView!
let longPressGesture = UILongPressGestureRecognizer(target: self, action: #selector(handleLongGesture(gesture:)))
@objc func handleLong
浏览 3提问于2017-10-11得票数 2
回答已采纳
1回答
试图了解在将列表键入为超类时如何访问子类的方法。这应该是基本的多态，但我有点糊涂了。
public class super
{
public Boolean isSuper()
{
return true;
}
}
public class sub : super
{
public Boolean isSuper()
{
return false;
}
}
现在我列出了这些对象的列表
List <super> myList = new List<super>();
myList.Add(new super());
myLis
浏览 2提问于2014-05-29得票数 1
2回答
目前，我正在学习Java中的继承，我很难理解它，但是我无法理解的主要问题之一是，为什么有必要在下面的示例中调用一个超类构造函数，以及它如何帮助？此示例来自Oracle关于super(...)方法的教程。
public MountainBike(int startHeight,
int startCadence,
int startSpeed,
int startGear) {
super(startCadence, startSpeed, startGear);
seatHeight =
浏览 0提问于2013-11-11得票数 0
回答已采纳
我正处于学习ES2015的过程中，我没有完全理解课堂的所有内容。据我所知，您定义了这样一个类：
class Parent {
constructor() {
// ...
}
}
以及这样的子类：(必须调用super()来从父类开始运行构造函数)。
class subClass extends Parent {
constructor(name, description, url) {
// subclass must call super to invoke the parent's constructor method
super();
}
浏览 7提问于2016-03-07得票数 2
回答已采纳
2回答
我想从父类创建一个子类。这是为了减少代码中的冗余。例如,
class Parent():
def __init__(self, a, b, c, d, e, f, g):
self.a = a
self.b = b
...
self.g = g
class Child1(Parent):
def __init__(self, a, b, c, d, e, f, g, h, i, j, k):
super().__init__(a, b, c d, e, f, g)
self.i = i
浏览 3提问于2018-07-05得票数 1
3回答
最近，我遇到了这个例子：
抽象轿车类
public abstract class Car {
private final Product product;
private final String carType;
public Car(Product product,String carType){
this.product = product;
this.carType = carType;
}
}
BigWheel类，扩展了Car类
public class BigWheel extends Car {
浏览 3提问于2016-07-05得票数 2
回答已采纳
1回答
我对编码和平移很陌生。我正在用youtube_dl和tkinter制作一个Downloader，我一般对TopLevel和OOP有几个问题。
下面是我的代码的一个简化版本(我刚刚删除了另一个按钮、图片等)
from tkinter import Button,Frame,Label,Toplevel,Tk
class Welcome:
def __init__(self,parent):
self.parent = parent
self.parent.title("YT Downloader")
self.parent.geomet
浏览 3提问于2021-08-05得票数 0
回答已采纳
每次我在Flash Builder中启动一个新的actionscript类时，它都以一行作为构造函数的开头
super()
我以前从未见过这种情况，而且它似乎没有任何意义。删除它会生成完全相同的电影。
为什么它被插入到我的新类中，它有什么作用？
浏览 1提问于2013-05-18得票数 2
我有个家长班
public class Parent
{
Database m_d;
Parent(Database d){
m_d = d;
}
}
还有一个孩子班
public class Child extends Parent implements java.lang.AutoCloseable
{
ChildDatabase m_d
Child()
{
// Error on the next statement:
// "Cannot reference m_database b
浏览 1提问于2019-02-01得票数 2
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
即时通信 IM
腾讯会议活动推荐
腾讯云开发者
