我有一个基类Shape,派生类和Ellipse和Rectangle.

在一个函数中,我有一个变量:

Shape activeShape(black, black, {0,0}, {0,0}, false);

后来在那个函数中:

activeShape = updateShape(isButton, activeShape, true);

updateShape 看起来像这样:

Shape updateShape(int button, Shape active, bool leftClick)
{
    switch(button)
    {
        case 1:
            return active;
        case 2:
            return Line(active.getFillColor(), active.getBorderColor(), active.getP1(), active.getP2(),false);
            break;
        case 3:
            return Rectangle(active.getFillColor(), active.getBorderColor(), active.getP1(), active.getP2(),false);
            break;
        case 4:
            return FilledRectangle(active.getFillColor(), active.getBorderColor(), active.getP1(), active.getP2(),false);
            break;
        case 5:
            return Ellipse(active.getFillColor(), active.getBorderColor(), active.getP1(), active.getP2(),false);
            break;
        case 6:
            return FilledEllipse(active.getFillColor(), active.getBorderColor(), active.getP1(), active.getP2(),false);
            break;
        default:
            if(leftClick)
            {
                active.setColor(getEnumColor(button), …

例如,

public class Foo
{
    public virtual bool DoSomething() { return false; }
}

public class Bar : Foo
{
    public override bool DoSomething() { return true; }
}

public class Test
{
    public static void Main()
    {
        Foo test = new Bar();
        Console.WriteLine(test.DoSomething());
    }
}

为什么答案是真的？"新酒吧()"是什么意思？"new Bar()"是不是意味着分配内存？

正如标题所说,如果我将指向基类的指针转换为派生类,当指针为空时,从C++ 11/C++ 14标准的角度来看,这是一个安全的操作吗？

struct base
{
   virtual ~base() = default;
};

struct derived : base {};

struct wrapper
{
   using allowed_derived_t = derived;
   base* base_ptr = nullptr;

   void set_ptr(base* ptr)
   {
       if (!dynamic_cast<allowed_derived_t*>(ptr))
          throw std::logic_error("Check your user code");

      base_ptr = ptr;
   }

   allowed_derived_t* ptr() const
   { return static_cast<allowed_derived_t*>(base_ptr); }
};

ptr()如果我在打电话之前打电话给它是安全的方法set_ptr吗？因为,在设置指针之前,base_ptr它不是必需的类型(allowed_derived_t),但是,动态指向对象不是错误的类型(因为没有指向对象).

标准在那种情况下说了什么？

我正在研究我的Java编程和面向对象编程.我一直挂断动态多态性的好处是什么？

看看下面的示例程序.为什么我会在示例2中使用示例1？

class SuperHero {
    private String power = ("Generic Power");
    public void useSuperPower() {
        System.out.println(power);
    }
}
class Spiderman extends SuperHero {
    private String power = ("Web sling!");
    public void useSuperPower() {
       System.out.println(power);
   }
}

class Wolverine extends SuperHero {
    private String power = ("Hack and Slash!");
    public void useSuperPower() {
        System.out.println(power);
    }
}

class main {
    public static void main (String args[]) {
        //example 1
        SuperHero hero = new SuperHero();
        SuperHero hero1 = new Spiderman();
        SuperHero hero2 = …

我最近开始编程,我忙于继承,多态和覆盖.现在我刚刚制作了这个程序,由于某些原因它不起作用.编译器强调"= new Arraylist();但我不知道为什么.

代码如下:

超级:人

public class Person {
private String firstName;
private String lastName;

public Person(String firstName, String lastName) {
    this.firstName = firstName;
    this.lastName = lastName;
}

public void print() {
    System.out.println("\t" + firstName + " " + lastName);
}
}

子类:老师

public class Teacher extends Person {
public Teacher(String firstName, String lastName) {
    super(firstName, lastName);
}

public void print() {
    System.out.println("Professor Details: ");
    super.print();
}

}

子类学生:

public class Student extends Person {
private int graduationYear;
private double …

我有一个问题,并想问你们为什么这些代码不起作用,如何在不删除泛型或方法的情况下使其工作.我认为这是因为该方法不能重载,因为S和T可以是同一类型,是否正确？但我仍然不知道如何让它发挥作用.谢谢!

public class GenericFail<S,T> {
    public void doAnything(S sValue){
        System.out.println("Doing anything with S");
    }

    public void doAnything(T sValue){
        System.out.println("Doing anything with T");
    }
}

我知道这个问题以前已被问过很多次了,我已经仔细阅读了它们,但这并没有帮助我回答我的问题类型.我对Haskell很新,

让我们假设我们有以下内容:

filter p [] = []
filter p (h:l) = if (p h) then (h:(filter p l)) else (filter p l)

我有两个问题

1. 我怎么称呼过滤器？我所知道的是你传递的p是一个列表

2. 老实说,我一般都不知道什么是多态类型,我无法弄清楚多态类型的过滤函数.

我没有事件了解函数过滤器在if语句中的作用.

如果你能帮我解决这两个问题,我将非常感激.

有很多资源可以解释多态性,但我不理解它们.

请考虑以下代码:

class Program
{
    static void Main(string[] args)
    {
        var a = new A();
        var b = new B();
        Print(a);
        Print(b);
        Console.WriteLine(b.Hello);
        Console.ReadLine();
    }

    static void Print<T>(T t) where T : A
    {
        Console.WriteLine(typeof(T));
        Console.WriteLine(t.GetType());
        Console.WriteLine(t.Hello);
    }
}

public class A
{
    public string Hello { get { return "HelloA"; } }
}

public class B : A
{
    public new string Hello { get { return "HelloB"; } }
}

我得到的输出(.NET FW 4.5)

• //打印(a)中
• 一个
• 一个
• HelloA
• //打印(b)中
• 乙 …

注意:为了清楚起见,在下面的代码片段中省略了constuctors/destructors和includes.

我正在使用一个函数registerCallback需要以下参数的库:

• 一个C风格的函数指针,用于注册回调
• 一个void*"用户-数据"传输任何一个认为合适的

因为我用C++编写代码而我希望我的回调函数调用一个类成员方法,由于registerCallback第一个参数的C样式,我不能直接做,我已经写了这个函数:

extern C {
    void handler( void* userData ) {
        (static_cast<Base*>(userData))->handle();
    }
}

我使用的registerCallback功能如下:

class Base {
    public void handle() {}
};
...
Base b;
registerCallback( handler, &b );

这到目前为止运作良好.

现在,让我们添加一些复杂性:

Baseclass有一个toto名为by 的纯虚函数handle(),我有Child1和Child2扩展的类Base.

class Base {
    public:
        void handle() { toto(); }
        virtual void toto() = 0;
};
class Child1: public Base {
    public: virtual void toto() …

我发现可以创建子类的实例并将其分配给父类的变量.我无法绕过这种情况.

在我的代码中,虽然实例是Human类.它在控制台中记录"我是动物"

我有几个问题:

1. 它甚至意味着什么？

2. 可能的结果是什么？

3. 为什么以及何时会有人做这种事情？

家长班:

public class Species
{
    public  String Shout()
    {
        return "I am an animal";
    }
}

儿童班:

public class Human : Species
{
    public new String Shout()
    {
        return "I am a Human";
    }
}

实例:

class Program
{
    static void Main(string[] args)
    {
        Species h = new Human();

        Console.WriteLine(h.Shout());
    }
}