相关疑难解决方法(0)

我在超类中有一个函数,它返回一个自己的新版本.我有一个继承特定函数的超类的子类,但宁愿它返回子类的新版本.我如何对其进行编码,以便当函数调用来自父级时,它返回父级的版本,但是当从子级调用它时,它会返回子级的新版本？

维基百科将虚拟方法定义为:

在面向对象的编程中,虚函数或虚方法是一种函数或方法,其行为可以通过具有相同签名的函数在继承类中被覆盖[以提供多态行为].

根据定义,除了 final方法和私有方法之外,Java中的每个非静态方法都是默认的虚拟方法.不能为多态行为继承的方法不是虚方法.

Java中的静态方法永远不能被覆盖; 因此,在Java中将静态方法声明为final是没有意义的,因为静态方法本身就像最终方法一样.它们可以通过具有相同签名的方法隐藏在子类中.显然是这样,因为静态方法永远不会有多态行为:被覆盖的方法必须实现多态,而静态方法则不然.

从前一段开始,可以推动一个重要的结论.默认情况下,C++中的所有方法都是静态的,因为除非在超类中显式声明为虚拟,否则C++中的任何方法都不能以多态方式运行.相比之下,除了final,static和private方法之外,Java中的所有方法都默认是虚拟的,因为它们默认具有多态行为(不需要在Java中将方法显式声明为虚拟,因此,Java没有像"virtual"这样的关键字).

现在,让我们演示实例变量(静态)也不能通过Java中的以下简单示例进行多态操作.

class Super
{
    public int a=5;
    public int show()
    {
        System.out.print("Super method called a = ");
        return a;
    }
}

final class Child extends Super
{
    public int a=6;

    @Override
    public int show()
    {
        System.out.print("Child method called a = ");
        return a;
    }
}

final public class Main
{
    public static void main(String...args)
    {
        Super s = new Child();
        Child c = new …

我正在阅读（出色的）书，Head First Design Patterns并且需要对观察者模式进行一些说明。下面的一些代码模拟了一个侦听天气模式更新的设备（CurrentConditionDisplay）。

接口：

public interface ISubject
{
    void RegisterObserver(IObserver obs);
    void RemoveObserver(IObserver obs);
    void NotifyObservers();
}
public interface IDisplay
{
    string Display();
}
public interface IObserver
{
    void Update(float temperature, float humidity, float pressure);
}

观察者

public class CurrentConditionDisplay : IObserver, IDisplay
{
    private float temperature;
    private float humidity;
    private float pressure;
    private ISubject weatherData;
    public CurrentConditionDisplay(ISubject weatherData)
    {
        this.weatherData = weatherData;
        this.weatherData.RegisterObserver(this);

    }
    public string Display()
    {
        StringBuilder sb = new StringBuilder();
        sb.AppendLine("Welcome to Current …

这是一个100%的理论问题,也许是基于意见的.

在一次专业的采访中,我得到了一个印刷页面,里面有很多写得很好,格式不正确的两个代码,class可以在演讲中逐行分析.让我们把这些数据结构A和B.没有问题陈述或有关预期行为的任何信息.

然而,他们的一个问题真让我生气.

在确定了算法的可疑行为以及许多潜在和实际错误后,他们要求我再确定一个错误.我发现了其他一些明显的问题,但我并没有弄清楚他们想要什么.好吧,当他们告诉我答案时,它引起了我的注意.的简化版本A,并B为下面的(我只留下这是他们的想法有一部分的方法):

template <typename T>
class A
{
public:

    // elements are dynamically allocated on the heap

    const T& getValue(unsigned i) const // I'm not even sure it was const
    {
        // return element at position 'i'
    }

    virtual void setValue(unsigned i, const T &value)
    {
        // sets the element at position 'i'
    }
};

template <typename T>
class B: public A<T>
{
public:

    virtual void setValue(unsigned i, …

我想从继承类调用的抽象类中调用抽象类的方法。

抽象类：

public abstract class Abstract {
    protected void updateMotionY(float deltaTime) {
        System.out.println("Abstrcat updateMotionY");
    }
    public void update(float deltaTime) {
        this.updateMotionY(deltaTime);
    }
}

继承类：

public class Obj extends Abstract {
    @Override
    protected void updateMotionY(float deltaTime) {
        System.out.println("updateMotionY");
        super.updateMotionY(deltaTime);
    }
    @Override
    public void update(float deltaTime) {
        super.update(deltaTime);
    }
}

主要方法类：

public static void main(String[] args) {
    (new Obj()).update(10.0f);
}

每当我尝试打电话时 new Obj().update()在主类中方法时，它都会打印“updateMotionY”和“Abstrcat updateMotionY”。我只想得到“Abstrcat updateMotionY”。

谁能告诉我如何解决这个问题？

假设我有一个名为Human. Baby并且Adult是 的子类Human。Human有一个run作为纯虚函数的函数，我不想Baby继承run但如果我不覆盖run，Baby将成为一个抽象类。

class Human{
 public:
   // Some human attributes.
   virtual void run()=0;
};

class Adult: public Human{
 public:
   void run(){
      // Adult running function
   }
};

class Baby: public Human{
 public:
   void run()=delete; //error

   // If I don't override `run` then Baby is marked as an abstract class

   void crawl(){
     // Baby crawling function.
   }
};

如果我标记run …

我最近在其他地方表达了我对此的看法*,但我认为值得进一步分析,所以我将其作为自己的问题发布.

假设我需要在程序中创建并传递容器.我可能对一种容器与另一种容器没有强烈的意见,至少在这个阶段,但我选择了一个; 为了论证,我们假设我将使用List <>.

问题是:编写我的方法接受并返回高级接口(例如C#的IEnumerable)会更好吗？或者我应该编写方法来获取并传递我选择的特定容器类.

我应该寻找哪些因素和标准来决定？什么样的程序可以从中受益？计算机语言会影响您的决定吗？性能？程序大小？个人风格？

(这甚至重要吗？)

**(家庭作业:找到它.但是在你寻找我自己之前请在这里发布你的答案,以免偏见你.)*

使用案例:我正在使用数据模板将View与ViewModel相匹配.数据模板通过检查最派生类型提供的具体类型的工作,他们不看什么接口提供,所以我必须这样做没有接口.

我在这里简化了示例并省略了NotifyPropertyChanged等,但在现实世界中,View将绑定到Text属性.为简单起见,假设带有TextBlock的View将绑定到ReadOnlyText,带有TextBox的View将绑定到WritableText.

class ReadOnlyText
{
    private string text = string.Empty;

    public string Text
    {
        get { return text; }
        set
        {
            OnTextSet(value);
        }
    }

    protected virtual void OnTextSet(string value)
    {
        throw new InvalidOperationException("Text is readonly.");
    }

    protected void SetText(string value)
    {
        text = value;
        // in reality we'd NotifyPropertyChanged in here
    }
}

class WritableText : ReadOnlyText
{
    protected override void OnTextSet(string value)
    {
        // call out to business logic here, validation, etc.
        SetText(value);
    }
}

通过重写OnTextSet并改变其行为,我是否违反了LSP？如果是这样,有什么更好的方法呢？

我遇到了以下java代码,我不确定它是什么意思.我们可以在实例化一个类之后在'{'中编写代码,例如新的TestClass {*/code goes here*/}

但是当我尝试运行代码时,我没有在输出中看到"Z是10".有人可以给我一些链接,我可以得到一些与java的这个功能相关的更多信息.

class TestClass {
    int z;
    public TestClass(){
    z=10;
    }
    public int getZ(){
    return z;
    }
    public void setZ(int z){
    this.z=z;
    }
}

class A
{   
    public static void main (String[] args) throws java.lang.Exception
    {
    TestClass TC = new TestClass() {
            public void testprint() {
        System.out.println("Z is " + getZ());
        }
     };
    }
}

我正在阅读方法重写，在其他语言中，似乎要完全重写，该方法必须具有相同的签名（参数、返回类型...等）

所以我试图检查 python 是否是这样工作的，我尝试了下一个代码

class Person():
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def print_name(self, last_name):
        print(self.name + " " + last_name)

class Superhero(Person):
    def __init__(self, name, age, power):
        super().__init__(name, age)
        self.power = power

    def print_name(self):
        print(self.name)


human = Person("Ron", 23)
super_human = Superhero("Superman", 30, "Flying")

human.print_name("Wesley")
super_human.print_name("Kent")

我收到一个错误，super_human.print_name("Kent")它需要一个参数，但我传递了两个参数，我知道 MRO 存在于 python 中，我在其中查看（对象>类>父类），所以我想知道是否有一个这样我就可以调用print_name()父类中存在的函数而不是当前函数，因为它们采用不同的参数。