面向对象编程

面向对象（OOP）设计：Object-Oriented Programming.

面向对象设计其实并没有什么深奥的，或者说至少没有你或者大部分人想的那样高深不可测，是且只是看待问题的角度不同而已。

在《测试驱动开发》这本书里面可曾提到这样的观点：面向对象编程语言有三种组织层次：

• 模块（java中即“包”）
• 类
• 方法

自我理解，也许肤浅，有待于慢慢更新领悟：

• 头文件
• 对象（对函数的封装）
• 函数

下面是一个测试用例，大致描述了面向对象技术，有助于理解：

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;

namespace WindowsFormsApplication2
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            ((Button)sender).Text = "Clicked!";                   //通过方法设置点击第一个button控件之后的显示
            Button newButton = new Button();
            newButton.Text = "New Button!";                       //创建第二个button控件
            newButton.Click += new EventHandler(newButton_Click);
            Controls.Add(newButton );                             //在窗体上面加入刚刚创建的button控件
        }
        private void newButton_Click(object sender, System.EventArgs e)
        {
            ((Button)sender).Text = "Clicked!";                   //通过方法设置点击第二个button控件之后的显示
        }

        private void Form1_Load(object sender, EventArgs e)
        {

        }
    }
}

面向对象编程中的几个小问题：

1）、下面那些项在OOP中有真实级别的可访问性？
      有的项：友元、公共、松散的、通配符。
      没有的项：安全、私有、受保护的。
   正解： public、private和protected是实际的可访问级别

2）、“必须手动调用对象的析构函数，否则就会浪费资源”的说法不正确，因为，创建好对象后，在函数最后结束的时候，程序会首先查看用户是否创建了析构函数，如果用户没有创建析构函数，那么函数会调用默认的析构函数，释放对象的资源，不会造成资源的浪费。
      正解：永远都不应该手动调用对象的析构函数，.net运行库环境会在垃圾回收过程中自动完成该任务。

3）、是的，只有创建一个对象，才能调用其类的静态方法。
     正解：不是，可以在没有任何类实例的情况下调用静态方法。
 

关于类、接口和继承的关系小测试程序：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication10
{
        public abstract  class MyBase  //定义MyBase类可以在任何地方访问，不能实例化，只能供继承只用
        {
            
        }
        internal class MyClass : MyBase      //只能在当前项目中访问类MyClass 继承自不能实例化只能供继承的MyBase大类
        {

        }
        public interface IMyBaseInterface1    //定义可以在任何地方访问的接口1
        {

        }
        internal interface IMyBaseInterface2  //定义只能在当前项目中使用的接口2
        {

        }
        internal interface IMyInterface : IMyBaseInterface1 ,IMyBaseInterface2 //定义只能在当前项目中使用的接口IMyInterface继承两个接口
        {

        }
        internal sealed class MyComplexClass : MyClass ,IMyInterface  //定义只能在当前项目中访问，不能供派生用，只能实例化
        {
                                                                      //类可以继承接口
        }
    class Program
    {
        static void Main(string[] args)
        {
            MyComplexClass  myObj = new MyComplexClass ();  //初始化对象
            Console .WriteLine (myObj .ToString ());
            Console .ReadKey();
        }
    }
} 

c#中定义类的几个基础问题：

在c#中定义类时，常常不需要定义相关的构造函数和析构函数。因为在建立代码时，如果没有提供构造和析构函数，编译器会自动添加。

在.NET中使用的析构函数叫做Finalize()这个函数有System.Object类提供。