方法

      值参数：

在方法声明时不加修饰的形参就是值参数，它表明实参与形参之间按值传递。当这个方法被调用时，编译器为值参数分配存储单元，然后将对应的实参的值赋值到形参中。实参可以是变量、常量、表达式，但要求其值的类型必须与形参声明的类型相同或者能够被隐式地转化为这种类型。这种传递方式的好处是，在方法中对形参的修改不影响外部的实参，也就是说数据只能传入方法而不能从方法传出，所以值参数有时也被称为入参数。

      引用参数：

引用与值参数不同，引用参数并不创建新的存储单元，它与方法调用中的实在参数变量同处一个存储单元，因此在方法内对形参的修改就是对外部实参变量的修改。

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

namespace Method_Sort
{
    class Myclass
    {
        public void Sort(ref int x, ref int y, ref int z)
        {
            int tmp;
            if (x > y)
            {
                tmp = x;
                x = y;
                y = tmp;
            }
            if (x >z)
           {
                tmp = x;
                x = y;
                y = tmp;
            }
            if (y >z)
            {
                tmp = x;
                x = y;
                y = tmp;
            }

        }
 
    }
    class Program
    {
        static void Main(string[] args)
        {
            Myclass m = new Myclass();
            int a, b, c;
            a = 30;
            b = 20;
            c = 10;
            m.Sort(ref a, ref b, ref c);
            Console .WriteLine ("a = {0}, b = {1}, c = {2}",a, b, c);
            Console .Read ();
        }
    }
}

使用ref时注意：
1、ref关键字仅对跟在它后面的参数有效，而不能应用于整个参数列表。

2、在调用方法时，也用ref修饰实参变量，因为是引用参数，所以要求实参与形参的数据类型必须完全匹配，二期实参必须是变量，不能是常量或者表达式。

3、在方法外，ref参数必须在调用之前明确赋值，在方法内，ref参数被视为已赋过初始值。

this关键字表示引用当前对象实例的成员，在实例方法体内也可以省略this，直接引用numItems，实际上两者的语义相同，而静态方法不与对象关联，理所当然地不能用this指针。this关键字一般用于实际构造函数、实例方法和实例访问器，以访问对象实例成员。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
/*商品销售管理，每一种商品对象要存储的是商品总数和商品的单价，没销售意见商品要计算销售额和库存*/
namespace cashRegister
{
    class cashRegister
    {
        int numItems;  //商品总数
        double cost;  // 商品单价
        static double cashSum;  //cashSum是静态变量，计算销售总额
        public cashRegister(int numItems, double cost)
        {
            this.numItems = numItems;
            this.cost = cost;

        }
        public cashRegister()
        {
            numItems = 0;
            cost = 0.0;

        }
        static cashRegister()
        {
            cashSum = 0.0;
            // this.cashSum = 0.0;  错误，静态方法不允许使用this
        }
        public void makeSale(int num)  //实例方法
        {
            this.numItems -= num;
            cashSum += cost * num;  
        }
        public static double productCost()  // 静态方法可以访问静态成员
        {
            return cashSum;
            // return this.cashSum;  错误，静态方法不能使用this
        }
        public int productCount()
        {
            return numItems;
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            cashRegister Candy = new cashRegister(200, 1);
            cashRegister Chips = new cashRegister(500, 3.5);
            Candy.makeSale(5);
            Console.Write("Candy.numItems = {0} 
 ", Candy.productCount());
            // 调用实例方法与对象Candy相关联
            Console.Write("cashSum = {0} 元
", cashRegister.productCost());
            // 调用静态方法与类cashRegister相关联
            Chips.makeSale(10);
            Console.Write("Chips.numItems = {0}
", Chips.productCount());
            //  调用实例方法与对象Chips相关联
            Console.WriteLine("cashSum = {0} 元
", cashRegister.productCost());
            // cashSum计Candy和Chips售出总价
            Console.Read();
        }
    }
}

方法的重载与覆盖

      一个方法的名字和形式参数的个数、修饰符及类型共同构成了这个方法的签名，同一个类中不能有相同签名的方法。如果一个类中有两个或者两个以上的方法同名，而它们的形参个数或形参类型不同是允许的，它们属于不同的方法签名。但是仅仅是返回类型不同的同名方法，编译器是不能识别的。

override   virtual

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

namespace virtual_override
{
    class A
    {
        public void F()
        {
            Console.WriteLine("A.F");
        }
        public virtual void G()
        { Console.WriteLine("A.G"); }
    }
    class B : A
    {
        new public void F()
        { Console.WriteLine("B.F"); }
        public override void G()
        {
            Console .WriteLine ("B.G");
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            B b = new B();
            A a = b;  //a是class A类型的引用，b是class B类型的引用
            a.F();
            b.F();
            a.G();
            b.G();
            Console.Read();
        }
    }
}

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

namespace virtual_override1
{
    public class Shape //定义基类 Shape
    {
        protected string Color;
        public Shape() { }
        public Shape(string Color)
        {
            this.Color = Color;
        }
        public string GetColor()
        {
            return Color;
        }
        public virtual double GetArea()
        {
            return 0.0;
        }
    }
        public class Circle : Shape // 定义Cicle类，从Shape类中派生
        {
            private double Radius;
            public Circle(string Color, double Radius)
            {
                this.Color = Color;
                this.Radius = Radius;
            }
            public override double GetArea()
            {
                return System.Math.PI * Radius * Radius;
            }
        }
        public class Rectangular : Shape  //派生类Rectangular，从Shape类中派生
        {
            protected double Length, Width;
            public Rectangular(string Color, double Length, double Width)
            {
                this.Color = Color;
                this.Length = Length;
                this.Width = Width;
            }
            public override double GetArea()
            {
                return Length * Width ;
            }
            public double PerimeterIs()  //周长
            {
                return (2 * (Length + Width));
            }
        }
        public class Square : Rectangular  //派生类Square 从Rectangular类中派生
        {
            public Square(string Color, double Side) : base(Color, Side, Side) { }
        }
    
    class Program
    {
        static void Main(string[] args)
        {
            Circle Cir = new Circle("orange", 3.0);
            Console.WriteLine("Circle color is {0},Circle area is {1}
", Cir.GetColor(), Cir.GetArea());
            Rectangular Rect = new Rectangular("Red", 13.0, 2.0);
            Console.WriteLine("Rectangular color is {0},Rectangular area is {1},Rectangular perimeter is {2}
", Rect.GetColor(), Rect.GetArea(), Rect.PerimeterIs());
            Square Squ = new Square("Green", 5.0);
            Console.WriteLine("Square color is {0},Square area is {1},Square perimeter is {2}
", Squ.GetColor(), Squ.GetArea(), Squ.PerimeterIs());
            Shape Shp = Cir;
            Console.WriteLine("Circle area is {0}
", Shp.GetArea());
            Shp = Rect;
            Console.WriteLine("Rectangular area is {0}
", Shp.GetArea());
            Console.Read();
        }
    }
}

 抽象类：

      抽象类是一种特殊的基类，并不与具体的事物相联系，抽象类的定义使用关键字abstract。抽象类不能被实例化，它只能作为其他类的基类。例如，并没有“图形”这种具体的事物，所以将“图形”定义为抽象类，派生了“圆形”和“四边形”这样一些可以产生具体实例化的普通类。

      在抽象类中也可以使用关键字abstract定义抽象方法，要求所有的派生非抽象类都要重载实现抽象方法。引入抽象方法的原因在于，抽象类本身是一种抽象概念，有的方法并不要求具体实现，而是留下来让派生类来重载实现。所以abstract的方法不能带有方法体，abstract与{}（方法体）不能共存。

抽象类和抽象方法的实现：

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

namespace abstract_override
{
    public abstract class Shape
    {
        protected string Color;
        public Shape() { }
        public Shape(string Color)
        {
            this.Color = Color ;
        }
        public string GetColor()
        {
            return Color;
        }
        public abstract double GetArea(); //抽象方法
    }
    public class Circle : Shape
    {
        private double Radius;
        public Circle(string Color, double Radius)
        {
            this.Color = Color ;
            this .Radius = Radius ;
        }
        public override double GetArea() // 重载
        {
            return System.Math.PI * Radius * Radius;
        }
    }
    public class Rectangular:Shape 
    {
        protected double Length, Width;
        public Rectangular(string Color, double Length, double Width)
        {
            this.Color = Color;
            this.Length = Length;
            this.Width = Width;
        }
        public override double GetArea() // 重载
        {
            return Length * Width;
        }
        public double PerimeterIs()
        {
            return (2 * (Length + Width));
        }
    }
    public class Square : Rectangular
    {
        public Square(string Color, double Side) : base(Color, Side, Side) { }
    }
    
    class Program
    {
        static void Main(string[] args)
        {
            Circle Cir = new Circle("orange", 3.0);
            Console.WriteLine("Circle color is {0},Circle area is {1}
", Cir.GetColor(), Cir.GetArea());
            Rectangular Rec = new Rectangular("red", 13.0, 2.0);
            Console.WriteLine("Rectangula color is {0},Rectangula area is {1},Rectangula perimeter is {2}
", Rec.GetColor(), Rec.GetArea(), Rec.PerimeterIs());
            Square Squ = new Square("green", 5.0);
            Console.WriteLine("Square color is {0},Square area is {1},Square perimeter is {2}
", Squ.GetColor(), Squ.GetArea(), Squ.PerimeterIs());
            Console.Read();
        }
    }
}