标签: subclass

在Objective-C中有Alloc/Init比喻.他们还添加了一个名为"new"的共享便捷方法,内部只是连续调用它们.如果我创建一个名为FooClass的NSObject的子类,FooClass会选择那些共享方法,包括'new'.

但是......实施的是怎么回事？

它不能简单地委托给基类,因为它只是实例化NSObject的实例,而不是派生类FooClass,但它仍然有效!那么有人会怎么写类似的东西？

换句话说,基类不应该是......

  + (id) somethingLikeNew{
        return [[NSObject alloc] init];  
    }

而是这......

  + (id) somethingLikeNew{
        return [[<SomethingThatMapsToFooClassType> alloc] init];  
    }

...其中'SomethingThatMapsToFooClassType'是从NSObject继承并且需要获取共享方法'somethingLikeNew'的派生类的类型.

基本上我是从NSObject添加一个类别,我有共享方法需要知道类型,但实现都是通用的,因此在NSObject上的类别而不是我的类文件中的所有地方(以相同的方式)你到处都没有'新'.它就在那里.)

任何人？Bueller？Bueller？

中号

可能重复:
在PHP中的子构造函数之前调用父构造函数

我有一个管理我的数据库连接的类.它有一个构造函数,从配置文件中获取数据库详细信息:

    class Database {
        function __construct(){
        //perform magic
        }
    }

我现在正在扩展这个类来创建一个用于管理用户创建和验证的类,我需要它仍然可以完成超类所做的事情,但需要一些额外的东西.

class Members {
      function __construct(){
       //perform super class magic
       // then perform your own magic
      }
}

这是怎样的正确方法？

我正在用CoffeScript编写一个库(所以JS),这是一个繁重的数学..我真的需要使用类型数组(Float64Array)和它们提供的所有性能.

那么扩展类型化数组功能的最佳方法是什么？

目前我正在做功能:

Vector =
    create: (ag...) ->
        CGE2Point.create ag...
    dot: (i,j) ->
        i[0]*j[0] + i[1]*j[1]
    add: (i,j) ->
        @.create i[0]+j[0], i[1]+j[1]
    sub: (i,j) ->
        @.create i[0]-j[0], i[1]-j[1]
    mul: (s,v) ->
        @.create s * v[0], s * v[1]
    div: (s,v) ->
        @.create v[0] / s, v[1] / s

但是拥有一个继承自类型化数组的Vector对象会非常好.我知道这个方法:

class Vector extends Float64Array

创建一个没有类型化数组的全部好处的类关于子类化数组的问题,阅读以下文章Dean Edwards建议从iframe获取对象副本,这个其他参考以其他方式做对不起Dean.但是类型化数组没有所有方法.

那么,如何正确(或至少最优雅和最佳)子类化类型化数组？或者我应该写所有类似的功能？

所以我不记得为我创建的新类进行单元测试.我尽力坚持TDD,但有时我会忘记.我很擅长运行测试(因为它只是一个按钮)所以有一种方法可以扫描所有类的命名空间,并检查它们是否来自已知的类.

例如.我有一个Contact课程.我有3个子类联系(运输,计费,服务)我有一个单元测试所有3.让我们说从现在起一个月我决定从联系人派出另一个班级.我非常擅长记得运行我的单元测试,但在这种情况下,我希望它只能通过1次测试来提醒我为我的新联系类编写单元测试.就像是.

    [TestMethod, TestCategory("Contact")]
    public void TestAllContactsAccountedFor()
    {
        foreach(class c in theNamespace)
        {
            bool subclassOfContact = c is  Contact;
            if (subclassOfContact)
            {
                bool knownSubclass = (c is CustomerShippingContact) || (c is CustomerBillingContact) || (c is CustomerServiceContact);
                Assert.IsTrue(knownSubclass);

            }

        }
    }

这样,如果我忘记进行测试,它将无法通过此测试,然后我会考虑它.有什么想法吗？

我有这样的事情:

class A {
    void add (A* a) {
        //add a to a vector<A*>
    }
    virtual void draw() = 0;
}

class B : public A {
    void tick() {}
    void draw() {}
}

class C : public A {
    void draw() {}
}

现在我想要做的是这样的循环:

for(int i=0; i<vector.size(); i++) {
    vector[i]->tick();
}

问题是,并非此向量中的所有元素都具有该tick()方法,但我仍然希望将它们放在同一个向量中,因为我还希望能够遍历向量并调用draw()所有元素.有什么方法可以解决这个问题吗？我正在考虑使用另一种载体,但我宁愿不这样做.

我有一个工作琐事游戏,我现在正试图实现一个高分.我创建了一个扩展SQLiteOpenHelper的子类DatabaseHelper类.我试图从另一个类调用子类DatabaseHelper中的方法,并得到错误.这些类不会编译,因此没有LogCat输出.我在代码中评论了错误.

代码结构建议也很受欢迎!

Highscores.java

public class Highscores extends Activity {

    DatabaseHelper dh;
    SQLiteDatabase db;

    @Override
    public void onCreate(Bundle savedInstanceState) {

        dh = new DatabaseHelper(context);
    }

    public class DatabaseHelper extends SQLiteOpenHelper { 

        public DatabaseHelper(Context context) { 
            //code
        }

        public boolean check(long score, int percentage) {
            //code
        }
    }
}

Results.java

public class Results extends Activity {

    DatabaseHelper dh;  //Error:  "DatabaseHelper cannot be resolved to a type."

    public void onCreate(Bundle savedInstanceState) {

        dh = new DatabaseHelper();  //Error:  "DatabaseHelper cannot be resolved to a …

所以,我有一个类GameObject,我用它作为许多子类的基础.

class GameObject()
{
    blah;
}

class AmmoBox() : Gameobject()
{
    different blah;
}

class Taco() : GameObject() {very different blah;}

后来我在列表中使用它们,我想为每个子类指定不同的更新/ etc行为.

foreach (AmmoBox a in GameObjects) { }

foreach (Taco t in GameObjects) { }

编译器抛出错误"无法将'GameObject'类型的对象强制转换为'AmmoBox'.我知道这是一个可怜的错误,我该怎么做呢？

问题是:有两个类,A和B.

public abstract class A
{
    public A()
    {
        Console.WriteLine("A");
    }
    public virtual void Fun()
    {
        Console.WriteLine("A.Fun()");
    }
}
public class B : A
{
    public B()
    {
        Console.WriteLine("B");
    }
    public new void Fun()
    {
        Console.WriteLine("B.Fun()");
    }

}

如果运行:

    public void Main()
    {
        A a = new B();
        a.Fun();
    }

输出是:

A
B
A.Fun()

如何解释这个结果,我知道它与抽象和成功有关,但我不知道如何解释.请帮忙.

我有以下类和typedef:

class Object

{
protected:
    long int id;
public:
    Object(void);
    ~Object(void) {};
    long int get_id(void);
};

typedef map<string, Object> obj_map;

然后我有了它的孩子:

class Image: public Object

{
private:
    path full_path;
    int x;
    int y;
    img image;
public:
    Image(path p, int x_pos = 0, int y_pos = 0);
    ~Image(void) {};

    void draw(int flags = 0);
    void move_north(float velocity);
    void move_south(float velocity);
    void move_west(float velocity);
    void move_east(float velocity);

    path get_path(void);
    img get_image(void);
    int get_x(void);
    int get_y(void);
    void set_path(path p);
    void set_image(img _image);
    void …

我是python的新手，正在尝试学习它。有人可以帮我一个简单的问题吗？我正在创建一个对象，如下所示：

 def myList(list):

    def __repr__(self):
    return list.__repr__(self)

所以基本上只是一个列表。但是然后在输入列表之后，我想立即将其值加倍。即

当我使用

 t = myList([1, 2, 3])
 print(t)

它应该输出 [2, 4 ,6]

现在我知道如何将列表中的每个元素加倍，例如可以使用

 l = [x * 2 for x in l]

但是我不确定如何在创建后立即访问myList对象的成员并将它们加倍。