Question

系统类

public class View
{
    //5 different constructors

    public virtual bool OnTouchEvent(MotionEvent e)
    {
        //Can't see inside
    }
}

我需要覆盖此OnTouchEvent，所以我尝试了这样：

public class MyClass : SystemClass
{
    public override View GetCellCore(/*params*/)
    {
        View v = base.GetCellCore(/*params*/);
        MyView mv = (MyView)mv;
        return mv;
    }

    private class MyView : View
    {
        //Implementation of the 5 different constructors

        public override bool OnTouchEvent(MotionEvent e)
        {
            //Do something
            return base.OnTouchEvent(e);
        }
    }
}

我需要覆盖此OnTouchEvent，以便我可以获取触摸信息。

Answer 1

您尝试做的事情无法正常工作，原因与此无关：

object obj = new object();
Dog dog = (Dog)object;

Dog继承自object，因为它继承自Animal（因为所有内容都来自object。）但您可能会明白为什么它不会感觉能够做到这一点。仅作为一个例子：

Animal cat = new Cat();
Dog dog = (Dog)cat;

object date = DateTime.Now;
Dog dog = (Dog)date;

如果对象可以通过这种方式进行转换，那么任何东西都可以像其他任何东西一样进行转换，而类型没有意义。

另一种看待它的方法是一个对象只有一种类型。如果您创建Dog的实例，则该对象的类型为Dog。永远不会有任何其他东西。它可以作为其基类型之一进行转换，也可以作为它实现的接口进行转换，但这并不会改变它的类型。

举例说明：

Dog dog = new Dog(); // It's a Dog
Animal animal = (Animal)dog; // It's cast as an Animal, but it's still a Dog.
object obj = (object)animal; // It's cast as an object, but it's still a Dog.

也许这有助于证明转换不能也不会改变对象的类型。因此，如果Animal已经已经 Dog，那么将Animal强制转换为Dog的唯一方法就是。

像这样：

var poodle = new Poodle(); // inherits from Dog
var animal = (Animal)poodle;
var dog = (Dog)animal;

这不会引发异常，因为贵宾犬是Animal和Dog.如果这清除了任何混淆，在这三行代码执行之后，还有只有一个对象。我们不会创建新对象，只是引用同一对象的新变量。

Answer 2

狗是动物（继承）动物并不总是一只狗（这就是为什么它不能在你的例子中运行）但可能是（这就是它编译的原因）。

Answer 3

我认为尽可能接近Dog是一个Animal构造函数。但它仍然没有多大意义。

public class Dog : Animal 
{
    public void Woof()
    { }
    public int DogTag { get; set; }  //you would have to make this up
    public Dog()
    { }
    public Dog (Animal animal) 
    {
        //now the dog is nothing more than an animal
    }
}

Dog dog = new Dog(animal);

Answer 4

Animal是一个系统类，对象是在内部创建的

这是不可能的，因为根本没有保证您的系统类确实是您的自定义类之一。但是，如果无法影响系统类，则可以实现自定义转换逻辑。

public sealed class SystemClass
{
}

public class CustomClass
{
    private SystemClass _systemClass;

    public CustomClass(SystemClass systemClass)
    {
        _systemClass = systemClass;
    }

    public static explicit operator CustomClass(SystemClass systemClass)
    {
        return new CustomClass(systemClass);
    }

    public static implicit operator SystemClass(CustomClass customClass)
    {
        return customClass._systemClass;
    }
}

这样您就可以添加附加功能，同时保持与底层基础架构的兼容性。

var system = new SystemClass();
var custom = (CustomClass)system;

将对象强制转换为实现它的类

4 个答案: