请修正.....

Question

题目：
定义一个Employee类，有两个虚方法 eat(),sleep()都是无参数，
*有一个子类Dev继承Employee.覆盖类eat方法
*还有一个子类HouJin继承了Employee,覆盖了sleep方法
*在Main方法 定义Dev对象、HouJin对象，分别赋值Employee的引用
然后都调用eat,sleep方法
 class Employee
        {
            public virtual void eat()
            {
 
            }
            public virtual void sleep()
            {            }
            
        }
        class Dev : Employee
        {
            public override void eat()
            {
                
            }
        }
        class HouJin : Employee
        {
            public override void sleep()
            {
                 
            }
        }
 
     static void Main(string[] args)
        {  
            Dev D = new Dev();
            D.eat();
            D.sleep();
            HouJin H = new HouJin();
            D.eat();
            D.sleep();
        } 
个人不明白“在Main方法 定义Dev对象、HouJin对象，分别赋值Employee的引用
然后都调用eat,sleep方法”这句话？所以代码就不怎麽懂了~

Answer 1

static void Main(string[] args) 
        {  
            Dev D = new Employee (); 
            D.eat(); 
            D.sleep(); 
            HouJin H = new Employee (); 
            H.eat(); 
            H.sleep(); 
        } 

Answer 2

可能是这个意思：
    static void Main(string[] args) 
        {  
            Dev D = new Employee(); 
            D.eat(); 
            D.sleep(); 
            HouJin H = new Employee(); 
            D.eat(); 
            D.sleep(); 
        } 

Answer 3

因为他们分别都继承了Employee这个类， Employee这个类里有eat 和 sleep 着两个方法 ，所以子类或者派生类中就可以使用Employee里面的两个方法！如果你在Employee类中 没有定义抽象方法，那么就按上面的代码 就可以实现。如果定义了抽象类 就必须在下面实现他们。

Answer 4

晕.我写错了.static void Main(string[] args) 
        { 
 Employee e = new Dev();
            e.eat();
            e.sleep();            e = new HouJin();
            e.eat();
            e.sleep();
 } 是这意思才对.呵呵.不好意思

Answer 5

这个实例其实就是说明虚方法和重写的使用,让你理解oop编程中的一些基本的东西.
你可以运行下面代码看一下输出结果using System;
using System.Collections.Generic;
using System.Text;
using System.Reflection;namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            Employee e = new Dev();
            e.eat();
            e.sleep();            e = new HouJin();
            e.eat();
            e.sleep();
            Console.ReadKey();
        }
    }    class Employee
    {
        public virtual void eat()
        {
            Console.WriteLine("Employee.eat");
        }
        public virtual void sleep()
        {
            Console.WriteLine("Employee.sleep");
        }    }
    class Dev : Employee
    {
        public override void eat()
        {
            Console.WriteLine("dev.eat");
        }
    }
    class HouJin : Employee
    {
        public override void sleep()
        {
            Console.WriteLine("houjin.sleep");
        }
    } 
}
输出:
/*
dev.eat
Employee.sleep
Employee.eat
houjin.sleep
*/

Answer 6

题目说的不明不白，很有误导的作用。
2楼的代码根本编译不过。
如果加了强制类型转换，编译是能通过了，运行的时候会出现exception

Answer 7

namespace My_lei
{
    class Program
    {
         
            static void Main(string[] args)
            {
                Employee e = new Dev();
                e.eat();
                e.sleep();                e = new HouJin();
                e.eat();
                e.sleep();
                Console.ReadKey();
            }
                class Employee
        {
            public virtual void eat()
            {
                Console.WriteLine("Employee.eat");
            }
            public virtual void sleep()
            {
                Console.WriteLine("Employee.sleep");
            }        }
        class Dev : Employee
        {
            public override void eat()
            {
                Console.WriteLine("dev.eat");
            }
        }
        class HouJin : Employee
        {
            public override void sleep()
            {
                Console.WriteLine("houjin.sleep");
            }
        } 
LZ请参详.....
也就是new一个对象然后再实现相应的方法。