标签: super

如果我对这里显而易见的事情一无所知,请原谅我,但是如果你在变量中保存对super的调用并稍后使用它会发生什么.

这是类定义的一部分,向您展示我的意思.

class CaselessDict(dict):

    def __init__(self, *args, **kwargs):
        self.super = super(CaselessDict, self) # save super
        self.update(*args, **kwargs)

    def __getitem__(self, key):
        key = self.parsekey(key)
        return self.super.__getitem__(key) # use saved super

当我实现这个CaselessDict类时几乎每个方法都有超级的东西.

下面的代码来自Objective-C中iPhone开发的iTunes U课程.我已经阅读了Apple文档,除了self之外,它都非常清楚.我有点理解自我是指向自己的指针,但究竟是什么意思呢？在下面的代码中,自我意味着什么？self.topSpeed和self.nearestWormhole在实现文件中有什么区别,或者在两种情况下self都指向同一个东西？self.topSpeed是指Planet*和self.nearestWormhole是指虫洞*？感谢任何回答的人,我已经学会了C,现在正在努力学习OOP,所以任何输入都会受到赞赏.

(Header file)
#import "Vehicle.h"
#import "Planet.h"
@interface Spaceship : Vehicle
@property (nonatomic) double topSpeed;
- (void)orbitPlanet:(Planet *)aPlanet
         atAltitude:(double)km;
@end





(Implementation file)
#import "Spaceship.h"
@interface Spaceship()
@property (nonatomic, strong) Wormhole *nearestWormhole;
@end

@implementation Spaceship
@synthesize topSpeed = _topSpeed;
@synthesize nearestWormhole = _nearestWormhole;

- (void)setTopSpeed:(double)speed
{
    if ((speed < 1) && (speed > 0)) _topSpeed = speed;
}

- (void)orbitPlanet:(Planet *)aPlanet atAltitude:(double)km
{
    double speed = self.topSpeed;
    if (speed > MAX_RELATIVE) speed = MAX_RELATIVE;
    [self.nearestWormhole travelToPlanet:aPlanet
                                 atSpeed:speed];
}
@end

我想将String参数传递为"null"

但是,这是构造函数中的超级方法 - 所以我不能这样做

String s = null;
super(s);

我不能这样做

super(null)

因为这将导致模糊的方法调用.我不希望有一个为null的实例变量,这似乎是不优雅的.

有没有办法创建一个空字符串？

NB

 new String(null) //does not compile

我正在尝试创建一个继承自str类型和第二类的派生类.这是有问题的,因为str类型不是简单地调用__init__,而是__new__由于其不变性而导致的方法.我知道for __init__和super工作得很好,你需要一直拥有相同的调用结构.但是,以下实现失败:

class base(object):
    def __new__(cls, *args, **kwargs):
        print "NEW  BASE:", cls, args, kwargs
        return super(base, cls).__new__(cls, *args, **kwargs)

    def __init__(self, *args, **kwargs):
        print "INIT BASE", args, kwargs

class foo(base, str):
    def __new__(cls, *args, **kwargs):
        return super(foo, cls).__new__(cls, *args, **kwargs)

    def __init__(self, *args, **kwargs):
        super(foo, self).__init__(*args, **kwargs)

这foo('cat')适用于:

>> NEW  BASE: <class '__main__.foo'> ('cat',) {}
>> INIT BASE ('cat',) {}

但是有了一个参数foo('cat', x=3),它失败了:

>> NEW  BASE: <class '__main__.foo'> …

我有关于泛型的问题:

Map<? super String, ? super String> mappa1 = new HashMap<Object,Object>();

超级可以实例化HashMap<Object,Object>a <? super String>.但是,您只能添加扩展String的对象(在本例中只是String本身).他们为什么不禁止编译错误以及使用extends通配符.我的意思是,如果曾经创建了一个Map <Object, Object>它可能只添加字符串..为什么不强制创建一个Map<String, String>首先？(就像extends通配符一样)

再次,我知道之间的差别super和extends有关仿制药.我想知道我上面提到的细节.

提前致谢.

是否可以从基类继承信号，并在派生类中将连接方法连接到它们？如果是，怎么办？

工作用例组成

实例化MyObject的MyWidget，并在微件起反应要由物体发射的信号。

from PySide.QtGui import QApplication, QMainWindow
from PySide.QtCore import QObject, QTimer, Signal
from PySide.QtGui import QLabel

class MyObject(QObject):
    sig = Signal()

    def __init__(self, parent=None):
        super().__init__(parent)
        QTimer.singleShot(3000, self.alert)
        QTimer.singleShot(5000, self.exit)
    def alert(self):
        self.sig.emit()
    def exit(self):
        print('All done')
        exit(0)

class MyWidget(QLabel):
    def __init__(self, parent=None):
        super().__init__(parent)
        self.monitor = MyObject(self)
        self.monitor.sig.connect(self.update)
    def update(self):
        print(2)

app = QApplication([])
w = MyWidget()
w.show()
app.exec_()

这是一个小巧但有效的示例，它打开了一个最小的空白窗口，self.monitor由小部件实例化的对象在3秒和5秒后发出计时器信号。第一个提示窗口小部件只在控制台上打印一个数字，第二个提示导致应用程序退出。

继承失败的测试用例

为了继承，仅将小部件类更改为：

class MyWidget(MyObject, QLabel):
    def __init__(self, parent=None):
        super().__init__(parent)
        self.sig.connect(self.update)
    def update(self):
        print(2) …

我在21天内使用Sams Teach Yourself Java学习Java(顺便说一下,这花了我超过21天的时间).在第5章中,最后的练习要求我创建一个类FourDPoint,它是Point的子类.我这样做了,但结果很有趣.我第一次做这个练习,这是我的代码:

import java.awt.Point;

class FourDPoint extends Point {
    int x;
    int y;
    int z;
    int t;

    FourDPoint(int x, int y, int z, int t){
        super(x, y);
        this.z = z;
        this.t = t;
    }

    public static void main(String[] arguments){
        FourDPoint fp = new FourDPoint(5, 5, 10, 10);
        System.out.println("x is " + fp.x);
        System.out.println("y is " + fp.y);
        System.out.println("z is " + fp.z);
        System.out.println("t is " + fp.t);
    }
}

结果:x为0,y为0,z为10,y为10.

我通过消除经过引用的x和y来改变我的代码,这给了我正确的答案.我的问题:为什么我得到x是0而y是0？intitiaized x和y优先于super(x,y)吗？

有一个简单的程序,在构造函数中,super()被调用而没有扩展到超类,我无法理解在这种情况下会做什么呢？

public class Student {

    private String name;
    private int rollNum;

    Student(String name,int rollNum){
        super(); //I can not understand why super keyword here.
        this.name=name;
        this.rollNum=rollNum;
    }


    public static void main(String[] args) {

        Student s1 = new Student("A",1);
        Student s2 = new Student("A",1);

        System.out.println(s1.equals(s2));
    }

}

假设我有3个类:A,B和C.A是B的基类,B是C语言.层次结构在这里保持正常,但对于一种方法,它应该是不同的.对于C类,它应该像从A继承的那样行事.

例如这样:

class A(object):
    def m(self):
        print 'a'

class B(A):
    def m(self):
        super(B, self).m()
        print 'b'

class C(B):
    def m(self):
        super(A, self).m()
        print 'c'

所以基本上它应该像这样工作:

a = A()
a.m()
a

b = B()
b.m()
a
b

c = C()
c.m()
a
c

但它不适用于C类,因为我收到此错误:

AttributeError: 'super' object has no attribute 'm'

要为C类解决这个问题,我可以从A类继承,但是我想继承B中的所有内容,并且m对于基类A ,该特定方法调用super.我的意思是该方法是一个例外.或者我应该以不同的方式为C类调用它以便工作？

我怎样才能做到这一点？

我是Java Android开发人员,我正在接近Kotlin

我已经定义了以下类:

open class Player : RealmObject() {
    ...
}

我定义了以下两个扩展,一个用于通用的RealmObject类,另一个用于特定的Player类:

fun RealmObject.store() {
    Realm.getDefaultInstance().use { realm ->
        realm.beginTransaction()
        realm.copyToRealmOrUpdate(this)
        realm.commitTransaction()
    }
}

fun Player.store(){
    this.loggedAt = Date()
    (this as RealmObject).store()
}

我想要的是如果我调用.store()任何RealmObject对象,RelamObject.store()扩展名将被调用但是如果我.store()在一个Player实例上调用将被调用的扩展名Player.store().(现在没问题)我不想复制粘贴相同的代码,我喜欢写更少的重用更多.所以我需要在内部Player.store()调用泛型RealmObject.store()

我知道了.我在那里写的代码实际上按预期工作:D

我要问的是(仅仅因为我是通过个人直觉写的):

这是好方法吗？!还是有更好的方法？

谢谢