标签: superclass

考虑以下代码:

class Test {
    Test() {
        System.out.println("In constructor of Superclass");
    }

    int adds(int n1, int n2) {
        return(n1+n2);
    }

    void print(int sum) {
        System.out.println("the sums are " + sum);
    }
}


class Test1 extends Test {
    Test1(int n1, int n2) {
        System.out.println("In constructor of Subclass");
        int sum = this.adds(n1,n2);
        this.print(sum);
    }

    public static void main(String[] args) {
        Test1 a=new Test1(13,12);
        Test c=new Test1(15,14);
    }
}

如果我们在超类中有一个构造函数,它将由我们为子类构造的每个对象调用(例如a,类Test1调用的对象Test1(int n1, int n2)以及它的父类Test()).

为什么会这样？

该程序的输出是:

在Superclass的构造函数中 …

我真的很难理解外卡参数.我有几个问题.

1. ?作为类型参数只能在方法中使用.例如:printAll(MyList<? extends Serializable>)我无法使用?类型参数定义类.

2. 我理解上限?. printAll(MyList<? extends Serializable>)意思是:" 如果它有实现接口的对象,printAll将打印.MyListSerialzable "
   我有一个问题super.printAll(MyList<? super MyClass>)意思是:" 如果它有对象或任何扩展的类(后代),printAll将打印.MyListMyClassMyClassMyClass "

在我出错的地方纠正我.

总之,只有T或E或K或V或N可以用作类型参数用于定义通用类.?只能用于方法

public void printAll(MyList<? super MyClass>){
    // code code code
}

根据Ivor Horton的书,MyList<? super MyClass>意味着MyList如果它具有MyClass它实现的对象或任何接口或类,我可以打印.也就是说,MyClass是一个下限 …

假设我有班级

class A {
protected:
    int x,y;
    double z,w;

public:
    void foo();
    void bar();
    void baz();
};

在我的代码和其他代码中定义和使用.现在,我想写一些可以很好地在A上运行的库,但它实际上更通用,并且能够操作:

class B {
protected:
    int y;
    double z;

public:
 void bar();
};

我确实希望我的库是通用的,所以我定义了一个B类,这就是它的API.

我希望能够告诉编译器 - 不是在我不再控制的A的定义中,而是在其他地方,可能在B的定义中:

请注意,请尝试将其B视为超类A.因此,特别是,将它放在内存中,这样如果我重新解释A*为a B*,我的代码期望B*s会起作用.并请然后实际接受A*的B*(和A&作为B&等等).

在C++中,我们可以通过另一种方式执行此操作,即如果B是我们无法控制的类,则可以执行"子类已知类"操作class A : public B { ... }; 我知道C++没有相反的机制 - "通过新的B类超类化已知的A类".我的问题是 - 这个机制最接近可实现的近似值是多少？

笔记:

• 这都是严格的编译时间,而不是运行时.
• 可以有没有任何的变化class A.我只能修改B知道两者A和的代码的定义和代码 …

我读过的所有ExtJS文档和示例都建议调用这样的超类方法:

MyApp.MyPanel = Ext.extend(Ext.Panel, {
  initComponent: function() {
    // do something MyPanel specific here...
    MyApp.MyPanel.superclass.initComponent.call(this);
  }
});

我已经使用这种模式很长一段时间了,主要的问题是,当你重命名你的类时,你还必须改变所有对超类方法的调用.这很不方便,经常我会忘记,然后我必须追查奇怪的错误.

但是看完来源Ext.extend(),我发现,这不是我可以使用superclass()或super()该方法Ext.extend()增加了原形:

MyApp.MyPanel = Ext.extend(Ext.Panel, {
  initComponent: function() {
    // do something MyPanel specific here...
    this.superclass().initComponent.call(this);
  }
});

在这个代码中,将MyPanel重命名为其他东西很简单 - 我只需更改一行.

但我怀疑......

• 我没有在任何地方看到过这种情况,旧的智慧说,我不应该依赖于无证件的行为.

• 我没有在ExtJS源代码中找到这些superclass()和supr()方法的单独使用.为什么在你不打算使用它们时创建它们？

• 也许这些方法在某些旧版本的ExtJS中使用但现在已被弃用？但它似乎是一个非常有用的功能,你为什么要弃用呢？

那么,我应该使用这些方法吗？

在Python 2.7和3中,我使用以下方法来调用超类的函数:

class C(B):
    def __init__(self):
        B.__init__(self)

我看到也可以B.__init__(self)用super(B, self).__init__()和替换python3 super().__init__().

这样做有什么优点或缺点吗？B至少直接为我调用它更有意义,但也许有一个很好的理由super()只能在使用元类时使用(我通常会避免).

我想序列化一个不受我控制的POJO类,但是想要避免序列化来自超类的任何属性,而不是来自最终类.例:

public class MyGeneratedRecord extends org.jooq.impl.UpdatableRecordImpl<...>,
    example.generated.tables.interfaces.IMyGenerated {
  public void setField1(...);
  public Integer getField1();

  public void setField2(...);
  public Integer getField2();
...
}

您可以从示例中猜测此类是由JOOQ生成的,并且继承自复杂的基类UpdatableRecordImpl,该类还具有一些类似于bean属性的方法,这会在序列化期间导致问题.此外,我有几个类似的类,所以最好避免为我生成的所有POJO重复相同的解决方案.

到目前为止,我找到了以下可能的解决方案:

• 使用mixin技术忽略来自超类的特定字段,如下所示:如何告诉jackson忽略我无法控制源代码的属性？

  这个问题是如果基类发生变化(例如,新的getAnything()方法出现在它中),它可能会破坏我的实现.

• 实现自定义序列化程序并在那里处理问题.这对我来说似乎有点矫枉过正.

• 顺便说一下,我有一个接口,它描述了我想要序列化的属性,也许我可以混合一个@JsonSerialize(as = IMyGenerated.class)注释......？我可以将此用于我的目的吗？

但是,从纯粹的设计角度来看,最好的方法是告诉杰克逊我只想序列化最终类的属性,并忽略所有继承的属性.有没有办法做到这一点？

提前致谢.

class p1(object): pass
class p2(p1): pass

所以p2是p1的子类.有没有办法以编程方式找出p1是[p2]的超类[es]之一？

您好我是Java新手,我在生产工人类中遇到此错误.我的生产工作者构造函数说明显了调用另一个构造函数.我不知道该怎么办？.

import java.util.Date;

public class Employee
{
      private String name, number;
      private Date date;

      public Employee(String name, String number, Date date)
      {
            setName(name);
            setNumber(number);
            setDate(date);
      }

      public void setName(String n)
      {
            name = n;
      }
      public void setNumber(String n)
      {
            number = n;
            // you can check the format here for correctness
      }
      public void setDate(Date d)
      {
            date = d;
      }

      public String getName()
      {
            return name;
      }
      public String getNumber()
      {
            return number;
      }
      public Date getDate()
      { …

我有一个超类,其方法调用其他只在其子类中定义的方法.这就是为什么当我创建一个超类的实例并调用它的方法时,它找不到该方法并引发错误.

这是一个例子:

class SuperClass(object):

  def method_one(self):
    value = self.subclass_method()
    print value


class SubClassOne(SuperClass):

  def subclass_method(self):
    return 'subclass 1'


class SubClassTwo(SuperClass):

  def subclass_method(self):
    return 'nubclass 2'


s1 = SubClassOne()
s1.method_one()

s2 = SubClassTwo()
s2.method_one()

c = SuperClass()
c.method_one()

# Results:
# subclass 1
# nubclass 2
# Traceback (most recent call last):
#   File "abst.py", line 28, in <module>
#     c.method_one()
#   File "abst.py", line 4, in method_one
#     value = self.subclass_method()
# AttributeError: 'SuperClass' object has no attribute 'subclass_method'

在创建新实例时,我正在考虑更改超类的 …

这不仅仅是一个难题而不是问题.我有以下代码:

public class PrivateBaseConstructor {
    public static class BaseClass {
        private BaseClass() {
        }

    }

    public static class DerivedClass extends BaseClass {
        public DerivedClass() {
            super(); // 1*
        }
    }
}

这里对super();1*的调用是允许的事件,尽管基类构造函数是private.如果我们将类作为单独的类编写在同一个包中:

BClass.java
public class BClass {
    private BClass() {

    }
}

DClass.java
public class DClass extends BClass {
    public DClass() {
        super(); // 2*
    }

由于基类构造函数不可见,编译器正确地在2*处给出错误.

当两个类在一个类中声明为静态时,为什么编译器不会在我的第一个场景中抛出错误？