今天看视频复习，又想起这个老掉牙的问题
一个类内的静态方法，在内存中只有一份，而普通方法会跟随实例的产生而被复制N多份
这种说法对不对，假如假设它是对的，那么就会有如下的问题：
copy数据是要花费时间的，而花费时间的多少显然和数据量的多少有直接关系，那么一个有100个方法的类显然会比有10个方法的类效率更低，因为同样生成一个实例，这个要复制100个方法过去而那个只需要复制10个，进而我们应该尽量把方法定义成静态的，因为速度比较快，是这样吗，C#自己的类比如string类就有几十个方法，能不能说string类的效率很低？
我认同这种观点：无论是static方法还是普通方法，无论有几个实例，它们在内存中有且只能有一份，而至于访问方法的不同，是另外一些机制的作用。

实例化对象时，对象调用的方法还是同一个方法，没有复制新方法，只不过内部传过去的参数不一样。
当实例化多个对象时，首先可以肯定，对象名肯定不一样：

1. class Program
   
2.     {
   
3.         static void Main(string[] args)
   
4.         {
   
5.             生物 s1 = new 生物("大毛",20);
   
6.             生物 s2 = new 生物("二毛",19);
   
7.             生物 s3 = new 生物("小明",18);
   
8.             s1.吃();
   
9.             s2.吃();
   
10.             s3.吃();
    
11.             Console.ReadKey();
    
12. 
    
13.         }
    
14.     }
    
15.     public  class 生物
    
16.     {
    
17.         public 生物(string name,int age)
    
18.         {
    
19.             this.Name = name;
    
20.             this.Age = age;
    
21.         }
    
22.         private string Name;
    
23.         private int Age;
    
24.         public void 吃()
    
25.         {
    
26.             Console.WriteLine("{0}今年{1}岁，现在{2}在吃食物",Name,Age,Name);
    
27.         }
    
28.       
    
29.     }

复制代码

输出的结果为：

夏闯富 发表于 2013-10-20 16:32
实例化对象时，对象调用的方法还是同一个方法，没有复制新方法，只不过内部传过去的参数不一样。
当实例化 ...

同意你的观点

动态方法,在使用时需要先创建实例,才能调用实例方法,而静态方法则不需要，直接使用即可。


//定义静态方法
class SQLHelper   
    {
        public static string aaa()
        {
            return “你好"        
        }
    }  

调用：
SQLHelper.aaa(); // 类名.方法名

//定义动态方法
class SQLHelper   
    {
        public string aaa()
        {
            return “你好"        
        }
    }
调用：
SQLHelper  s =new SQLHelper ();
s.aaa();