.Net中几个容易混淆的概念

 

 1.值类型与引用类型
    .Net语言类型分为两类:值类型和引用类型.
    值类型的变量直接包含其数据,而引用类型的变量存储对其数据的引用.
    对于引用类型,两个变量可能引用同一个对象,因此对一个变量的操作可能影响另一个变量所引用的对象.
    对于值类型,每一个变量都具有自己的数据副本,对一个变量操作不可能影响另一个变量.
    大部分固有的基本类型（如int, char）是值类型，structs 也是值类型。引用类型包括类、接口、数组和字 
    符串。基本的概念非常简单，那就是一个值类型的实例代表了实际的数据（存在栈中），而一个引用类
     型的实例代表指向数据的指针或者引用（存在堆中）。

2.堆与堆栈
   GC的全称是garbage collection，中文名称垃圾回收，是.net中对内存管理的一种功能。垃圾回收器跟踪
  并回收托管内存中分配的对象，定期执行垃圾回收以回收分配给没有有效引用的对象的内存。当使用可
  用内存不能满足内存请求时，GC会自动进行。
  内存有堆栈和堆的概念。堆栈遵循后进先出的原则.
    
3.传值与传址的区别
   方法的参数传递有四种:传值,传址,输出参数,数组参数.
   传值参数无需额外的修饰符，传址参数需要修饰符ref，输出参数需要修饰符out，数组参数需要修饰符params.传值参数在方法调用过程中如果改变了参数的值，那么传入方法的参数在方法调用完成以后并不因此而改变，而是保留原来传入时的值。传址参数恰恰相反，如果方法调用过程改变了参数的值，那么传入方法的参数在调用完成以后也随之改变。实际上从名称上我们可以清楚地看出两者的含义--传值参数传递的是调用参数的一份拷贝，而传址参数传递的是调用参数的内存地址，该参数在方法内外指向的是同一个存储位置.

传值与传址的区别
 1//传值
 2static void Swap(int x,int y) 
 3{
 4   int temp = x;
 5   x = y;
 6   y = temp;
 7}
 8//传址
 9static void Swap(ref int x, ref int y) 
10{
11    int temp = x;
12    x = y;
13    y = temp;
14}
15//方法调用
16int i = 1, j = 2;
17Swap(i,j);
18Response.Write("传值：<br>"+"i:"+i.ToString()+"<br>j:"+j.ToString()+"<br>");
19Swap(ref i, ref j);
20Response.Write("传址：<br>i:"+i.ToString()+"<br>j:"+j.ToString());
21/**//*
22传值：
23i:1
24j:2
25传址：
26i:2
27j:1 
28*/
29//先传址后传值
30int i = 1, j = 2;
31Swap(ref i, ref j);
32Response.Write("传址：<br>i:"+i.ToString()+"<br>j:"+j.ToString()+"<br>");
33Swap(i,j);
34Response.Write("传值：<br>"+"i:"+i.ToString()+"<br>j:"+j.ToString()+"<br>");
35/**//*
36传址：
37i:2
38j:1
39传值：
40i:2
41j:1
42*/

4.委托与事件      
   MSDN中的定义：
       A delegate declaration defines a reference type that can be used to encapsulate a methord with a specific signature.
     A delegate instance encapsulate  a static or an instance method. Delegates are rughly similar to function pointers in c++;
     howerver,delegate are type-safe and secure.

    C#编程指南中的定义：
     委托是一种引用方法的类型，一旦为委托分配了方法，委托将与该方法具有完全相同的行为。委托方
    法的使用可以象其他任何方法一样，具有参数和返回值。
  
    委托是函数的封装，它代表一“类”函数。他们都符合一定的签名：具有相同的参数列表和返回值。同
   时委托也可以看成是对函数的抽象，是函数的“类”。此时，委托的实例将代表一个具体的函数。
    
    如何委托：

委托的声明与使用
1public delegate void Del(string message);
2public void DelegateMethod(string message)
3{
4   Console.WriteLine(message);
5}
6Del handler = new Del(DelegateMethod)
7handler("Hello World");

5. 重载与覆写
    重载(overload):
    同一类中定义的方法可能具有不同的版本,此时需要使用 重载
    方法名必须相同.;参数类型必须不相同;返回值类型不做要求(可以相同,也可以不同)

重载的示例代码:
 1public class Account
 2    {
 3        public double balance;
 4        public bool Withdraw(double amt)
 5        {
 6            //银行存款>要取的金额时返回真
 7            if(balance >= amt)
 8            {
 9                balance -=amt;
10                return true;
11            }
12            else
13            {
14                return false;
15            }
16        }
17        //根据取钱金额
18        public bool Withdraw(double amt,double Maxvalue)
19        {
20            //银行存款>要取的金额，且所取金额必须小于每次可取最大金额
21            if(balance >= amt)
22            {
23                if(amt< Maxvalue)
24                {
25                    balance -=amt;
26                    return true;
27                }
28                else
29                {
30                    return false;
31                }
32            }
33            else
34            {
35                return false;
36            }
37        }
38    }

   覆写(override)
   子类中为了满足自己特殊的需求,重复定义父类中的方法.
   注意:只有虚方法和抽象方法才能被覆写.
   要求方法名，参数列表，返回值类型都相同．

覆写的示例代码
 1//父类
 2public class Account
 3{
 4　public double balance;
          //虚方法:
 5　public virtual bool Withdraw(double amt)
 6　{
 7    balance -=amt;
 8    return true;
 9　}
10}
11//子类
12public class CheckAccount :Account
13{
14 public override bool Withdraw(double amt)
15 {
16   //通过base关键字访问父类的成员
17   if(base.balance >= amt)
18   {
19    base.balance -=amt;
20    return true;
21   }
22   else
23   {
24    return false;
25   }
26 }
27}

6.虚方法(关键字: virtual)与抽象方法(关键字: abstract)
   虚方法可以有自己的实现体,它与普通区别仅在于虚方法可以被覆写,而普通方法不可以.
   抽象方法必须被派生类覆写,可以看成是没有实现体的虚方法.
   注意:如果类中具有抽象方法，那么这个类必须被定义为抽象类.
 

111
 1//父类,抽象类
 2public abstract class Account
 3{
 4   public double balance;
 5   //抽象方法
 6   public abstract bool Withdraw(double amt);
 7}
 8//子类
 9public class CheckAccount :Account
10{
11  public override bool Withdraw(double amt)
12  {
13    if(base.balance >= amt)
14    {
15    base.balance -=amt;
16    return true;
17    }
18   else
19   {
20    return false;
21    }
22   }
23}