困惑程序员一生的问题之一(下面的二个类那种封装方法更好)

Question

///类的写法一:省去命名空间，省去构选函数，就写法来讨论
class Add1
{
    private int m_FirstNumeber;
    private int m_SecondNumber;
    public int FirstNumber
    {
       get{ FirstNumber = m_FirstNumber;}
       set{ m_iFirstNumber = value;}
    }
    public int SecondNumber
    {
       get{ SecondNumber = m_SecondNumber;}
       set{ m_SecondNumber = value;}
     }
     public int Add()
     {
        return m_FirstNumber + m_SecondNumber;
     }
}
///类的写法2
class Add2
{
   private int m_FirstNumeber;
   private int m_SecondNumber;   public int Add(m_FirstNumber, m_SecondNumber)
   {
     return m_FirstNumber + m_SecondNumber;
    }
}
///这二个类都实现一个功能，就是二数相加，下面是引用!
int sum = 0;
Add1 add1 = new Add1();
add1.FirstNumber = 1;
add1.SecondNumber = 1;
sum = add1.Add();
///这一种方法，是对类的属性付值，然后调用这个类的方法！
int sum = 0;
Add2 add2 = new Add2();
sum = add2.Add(1, 1);
///这一种方法，真接向方法输入二个参数，然后调用这个类的方法！
在C#没出来之前，都用第二种方法，现在有了C#就多了一种方法！
请问那种方法的运行效率高呢！如果相同的话，你们让为要用那种方法啊！
我好郁闷啊，帮一下我吧！我认为第一种方法的可读性好！当写的代码多！
第二种的可读性差一些，便写的代码少！

Answer 1

我喜欢第二种，首先，用惯了，这也是一种久经检验的写方，我喜欢用成熟的东东，新出的产品，是不得去作实验品的。
其次，C#的那种方式，对于大型一些的东东，适用，像这种很小的东东，还是效率为上，而且，小东东，一般是被调用执行的频率很高，所有哪怕一次能省一点时间，N次执行，不是就省N多时间了吗
所以，在这种情况下，我选第二种，老方式

Answer 2

如果m_FirstNumeber;
    int m_SecondNumber；
这两个成员没别的用处的话，显然是第二个（这时，第一个是毫无疑义的）
但如果这两个成员由别的地方需要用到那肯定是第一个好

Answer 3

第一种,如果其中一个值没赋调用ADD时怎么办?
第二种,还需要那两个成员变量吗?根本就没用到吧?

Answer 4

class Add2
{
   private int m_FirstNumeber; //
   private int m_SecondNumber; // 这两行根本就是废物   public int Add(m_FirstNumber, m_SecondNumber) // 还不如直接用static
   {
     return m_FirstNumber + m_SecondNumber;
    }
}|
Vclass Add2{
    public static int Add(int v1, int v2) { return v1+v2; }
}int sum = Add2.Add(1, 1);

Answer 5

回复了我才发现问题……
public int Add(m_FirstNumber, m_SecondNumber)
这行能编译才怪

Answer 6

第2种方法有点象VB写function
如果加上static的话
直接 类名.方法名(参数)就可以了
这样的话就破坏了类的封装比如System.Console类
其实微软是用了sealed来防止继承

Answer 7

要说“封装”的话，当然是第一种好，但是如果整个类的作用只是一两个方法，根本不需要用到“对象”来保存状态（例如楼主例子里的两个数字）的话，还不如直接用静态方法，也就是不进行任何封装，类的存在只作为一系列静态方法的“归类”。回到楼主的例子，如果对两个数字需要多次求和，过程中不改变两个加数的话，封装就有一定道理，因为可以使用对象保存这两个会多次用到的数字（也就是我说的“状态”）；但是如果每次相加的两个数都不同，也就是不存在“状态”，那就根本不需要使用封装了。此外，虽然我也不清楚我这么做对不对，但是对于全局范围来说都只需要存在一个实例的对象，我也倾向于将状态也“静态”化，即全部成员加上static。这时候，使用类名来访问它的成员不需要经过实例化，但是我倾向于想象成直接使用类名来访问唯一的实例，例如System.Console类，我会理解成System.Console类的唯一实例。

Answer 8

public sealed class Consolepublic static void WriteLine()
public static void WriteLine(bool value)
……

Answer 9

public class
{
    int first = 0;
    int second = 0;    public int First
    { get { return first; }
      set { first = value; }
    }
    
    public int Second
    { get { return second; }
      set { second = value; }
    }    public int Add()
    { return first + sencond; }
   
    public int Add(int p1, int p2)
    {
       first = p1;
       second = p2;
       return Add();
    }
}

Answer 10

第一种在生成器模式中比较常见，一般都是用第二种。但是如果参数太多或者生成的结果太复杂，一般会用生成器模式，例如UriBuilder，看起来就是第一种那样。但是在楼主举的例子里面，第一种纯粹是吃饱了撑了没事干自找麻烦……。

Answer 11

谢谢大家的帮忙，特别感谢netmicro说的很详细!THANK