2.抽象类和接口的区别
解答：
抽象类（abstract class）可以包含功能定义和实现，接口（interface）只能包含功能定义
抽象类是从一系列相关对象中抽象出来的概念， 因此反映的是事物的内部共性；接口是为了满足外部调用而定义的一个功能约定， 因此反映的是事物的外部特性
分析对象，提炼内部共性形成抽象类，用以表示对象本质，即“是什么”
为外部提供调用或功能需要扩充时优先使用接口

3. C#语言中，值类型和引用类型有何不同
解答：
值类型和引用类型的区别在于，值类型的变量直接存放实际的数据，而引用类型的变量存放的则是数据的地址，即对象的引用。
值类型变量直接把变量的值保存在堆栈中，引用类型的变量把实际数据的地址保存在堆栈中，而实际数据则保存在堆中。注意，堆和堆栈是两个不同的概念，在内存中的存储位置也不相同，堆一般用于存储可变长度的数据，如字符串类型;而堆栈则用于存储固定长度的数据，如整型类型的数据int(每个int变量占用四 个字节)。由数据存储的位置可以得知，当把一个值变量赋给另一个值变量时，会在堆栈中保存两个完全相同的值;而把一个引用变量赋给另一个引用变量，则会在 堆栈中保存对同一个堆位置的两个引用，即在堆栈中保存的是同一个堆的地址。在进行数据操作时，对于值类型，由于每个变量都有自己的值，因此对一个变量的操 作不会影响到其它变量;对于引用类型的变量，对一个变量的数据进行操作就是对这个变量在堆中的数据进行操作，如果两个引用类型的变量引用同一个对象，实际 含义就是它们在堆栈中保存的堆的地址相同，因此对一个变量的操作就会影响到引用同一个对象的另一个变量。

4.结构和类的区别
解答：
1) 结构是一个值类型，保存在栈上，而类是一个引用类型，保存在受管制的堆上。
2) 对结构中的数据进行操作比对类或对象中的数据进行操作速度要快。
3) 一般用结构存储多种类型的数据，当创建一个很多类或对象共用的小型对象时，使用结构效率更高。

4.抽象方法和虚方法的区别
解答：
抽象方法
使用abstract关键字 public abstract bool Withdraw(…);
抽象方法是必须被派生类覆写的方法。
抽象方法是可以看成是没有实现体的虚方法
如果类中包含抽象方法，那么类就必须定义为抽象类，不论是否还包含其它一般方法
虚方法
使用virtual关键字 public virtual bool Withdraw(…);
调用虚方法，运行时将确定调用对象是什么类的实例，并调用适当的覆写的方法。
虚方法可以有实现体
———————————————————————————————
虚拟方法和抽象方法有什么区别？
抽象方法只有声明没有实现，需要在子类中实现；虚拟方法有声明和实现，并且可以在子类中覆盖，也可以不覆盖使用父类的默认实现
虚拟方法有实现代码
抽象方法则没有，
并且抽象类不能被实例化，只能实例化实现了全部抽象方法的派生类
抽象方法是虚拟方法的一种
抽象方法没有实现，它的存在只是为派生类统一接口；派生类应该实现这个方法
如果编写一个基类，它永远不会被实现，那么就应该将这个类中的一个或多个方法定义为
抽象方法。
抽象方法只有声明没有实现，需要在子类中实现；虚拟方法有声明和实现，并且可以在子类中覆盖，也可以不覆盖使用父类的默认实现
补充一点
只允许在抽象类中使用抽象方法声明
学习
其实大家首先要搞清楚，虚方法与多态性关系密切，虚方法允许派生类完全或部分重写该类的方法，需写方法体。抽象类中可以包含抽象方法与一般的方法，抽象类不 可以new,抽象方法只是一个定义，没有方法体，也就是没有{}，也不要在里面写内容。它们两个相像的一点是都用override重写

摘自：http://www.zxbc.cn/html/20090419/70325.html

User.cs

class User
{
    private int _id;
    public int ID
    {
        get { return _id; }
        set { _id = value; }
    }

    private string _name;
    public string NAME
    {
        get { return _name; }
        set { _name = value; }
    }
}

IUser.cs

interface IUser
{
    void Insert(User user);

    User GetUser(int id);
}

SqlserverUser.cs

class SqlserverUser : IUser
{
    public void Insert(User user)
    {
        Console.WriteLine("在SQL Server中给User表增加一条记录。");
    }

    public User GetUser(int id)
    {
        Console.WriteLine("在SQL Server中根据ID得到User表一条记录。");
        return null;
    }
}

AccessUser.cs

class AccessUser : IUser
{
    public void Insert(User user)
    {
        Console.WriteLine("在Access中给User表增加一条记录。");
    }

    public User GetUser(int id)
    {
        Console.WriteLine("在Access中根据ID得到User表一条记录。");
        return null;
    }
}

Department.cs

class Department
{
    private int _id;
    public int ID
    {
        get { return _id; }
        set { _id = value; }
    }

    private string _deptName;
    public string DeptName
    {
        get { return _deptName; }
        set { _deptName = value; }
    }
}

IDepartment.cs

interface IDepartment
{
    void Insert(Department department);

    Department GetDepartment(int id);
}

SqlserverDepartment.cs

class SqlserverDepartment : IDepartment
{
    public void Insert(Department department)
    {
        Console.WriteLine("在SQL Server中给Department表增加一条记录。");
    }

    public Department GetDepartment(int id)
    {
        Console.WriteLine("在SQL Server中根据ID得到Department表一条记录。");
        return null;
    }
}

AccessDepartment.cs

class AccessDepartment : IDepartment
{
    public void Insert(Department department)
    {
        Console.WriteLine("在Access中给Department表增加一条记录。");
    }

    public Department GetDepartment(int id)
    {
        Console.WriteLine("在Access中根据ID得到Department表一条记录。");
        return null;
    }
}

IFactory.cs

interface IFactory
{
    IUser CreateUser();

    IDepartment CreateDepartment();
}

SqlserverFactory.cs

class SqlserverFactory : IFactory
{
    public IUser CreateUser()
    {
        return new SqlserverUser();
    }

    public IDepartment CreateDepartment()
    {
        return new SqlserverDepartment();
    }
}

AccessFactory.cs

class AccessFactory : IFactory
{
    public IUser CreateUser()
    {
        return new AccessUser();
    }

    public IDepartment CreateDepartment()
    {
        return new AccessDepartment();
    }
}

Client.cs

class Client
{
    static void Main(string[] args)
    {
        User user = new User();
        Department department = new Department();

        IFactory factory = new SqlserverFactory();
        //IFactory factory = new AccessFactory();

        IUser iu = factory.CreateUser();
        iu.Insert(user);
        iu.GetUser(1);

        IDepartment id = factory.CreateDepartment();
        id.Insert(department);
        id.GetDepartment(1);

        Console.Read();
    }
}

小结：

• 本例分析：只有一个User类和User操作类时，是只需要工厂模式的，但现在加入新表，而且SQL Server与Access又是两大不同的分类，所以解决这种涉及多个产品系列的问题，用到了抽象工厂模式。
• 优点：最大的好处是易于交换产品系列，由于具体工厂类，如IFactory factory=new AccessFactory()，在一个应用中只需要在初始化时出现一次，这就使得改变一个应用的具体工厂变得非常容易，它只需要改变具体工厂即可使用不同的产品配置；第二大好处是，它让具体的创建实例过程与客户端分离，客户端是通过它们的抽象接口操纵实例，产品的具体类名也被具体工厂的实现分离，不会出现在客户代码中。
• 缺点：比如我们要增加项目表Project，至少要增加三个类，IProject、SqlserverProject、AccessProject，还需要更改IFactory、SqlserverFactory和AccessFactory才可以完全实现；另外，客户端程序类不只一个时，很多地方都在用IUser或IDepartment，每一个类在开始都会声明IFactory factory=new SqlserverFactory()，如果我有100个调用数据库的类，就要更改100次IFactory factory=new SqlserverFactory()。［此种情况时可以考虑用简单工厂模式＋抽象工厂模式进行，随后也可以再过渡到反射＋抽象工厂模式（反射＋配置文件）］。

简单工厂：

工厂方法：

1、简单工厂模式下，工厂类与具体父类及具体子类都有关联；而工厂模式下，工厂类只与具体父类有关联，由工厂子类负责与具体子类进行关联。

2、如果在简单工厂模式下加入新功能扩展，就要对工厂类做修改，加入新功能；而在工厂模式下，只是单纯地加入工厂子类和具体子类，而不需要对工厂类做修改，做到了“开放扩展，封闭修改”。

3、其实尽管对工厂类不需要做修改了，但是也要对客户端做修改，因为添加了对新功能的调用。也就是说工厂模式做到了对工厂类的开闭原则，却解决不了对客户端的修改。

4、一些情况下，可以考虑用工厂模式＋反射来解决客户端修改问题。