C#_类

1：访问修饰符

访问修饰符可以定义应用程序中类成员的作用域。和C++有一些不同，下面说明一下：

public:访问不受限制，public成员可以被任何其他类访问。

private:访问只限于包含该成员的类，只有包含该成员的类才可以访问。

protected:访问限于包含该成员的类及该类的派生类。

internal:访问只限于所在的程序集，只有在同一程序集内的类才可以访问该成员。

protected internal:访问限于包含该成员的类、其派生类，及与其位于同一个程序集内的类。

2：创建对象

在C#语言中，每创建一个对象，都会首先调用new关键字后面指明的构造函数，来初始化该类对象，具体语法如下：

<类名><对象名>=new<构造函数(参数列表)>

new关键字示例：

Circle c=new Circle(0,0,10);

　　访问对象成员的语法如下：

<对象名>.<成员名>

访问对象成员的示例：

double area;
area=c.getArea();

3：以一个例子总结创建类和对象的过程

（1）创建一个名为Circle的类，其内部代码如下：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace ConsoleApplication38
{
    class Circle//定义Circle类
    {
        //定义字段
        private int radius;
        //定义方法
        //构造函数
        public Circle(int radiusValue)
        {
            radius = radiusValue;
        }
        //为radius字段编写setR()方法，为radius字段赋值，注意对字段要验证其合法性
        public void setR(int radius_1)
        {
            if (radius_1 >= 0)
                radius = radius_1;
            else
                radius = 0;
        }
        //为radius字段编写getRadius()方法，以便于用户获取字段值
        public int getRadius()
        {
            return radius;
        }
        //定义getArea()方法求圆面积
        public double getArea()
        {
            return 3.14 * radius * radius;
        }
    }
}

（2）在Program.cs文件中编写如下代码：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace ConsoleApplication38
{
    class Program
    {
        static void Main(string[] args)
        {
            double r;
            Circle circle = new Circle(1);//创建Circle类对象circle
            r = circle.getArea();//调用对象circle的getArea()方法成员
            Console.Write("圆半径为" + circle.getRadius() + "的圆面积:");
            Console.WriteLine(r);
 
            circle.setR(10);
            r = circle.getArea();//调用对象circle的getArea()方法成员
            Console.Write("圆半径为" + circle.getRadius() + "的圆面积:");
            Console.WriteLine(r);
            Console.ReadLine();
 
        }
    }
}

（3）运行结果：

4：方法

方法就相当于函数

（1）方法的定义和调用示例

class Circle//定义Circle类
{
    ......
    //定义getArea()方法求圆面积
    public double getArea()
    {
        return 3.14*radius*radius;
    }
}
class Program
{
    static void Main(string[]args)
    {
        double area;
        Circle circle=new Circle(1);
        area=circle.getArea();//调用getArea()方法
        Console.Write(circle.getRadius()+";");
        Console.WriteLine(area);
        Console.ReadLine();
    }
}

(2)方法中的参数传递之值传递

class Program
{
    static void Main(string[]args)
    {
        int a=3;
        Square(a);
        Console.WriteLine(a);
        Console.ReadLine();
    }
    static void Square(int x)
    {
        x=x*x;
    }
}

　　调用Square()方法时，先将变量a的复制值传递给Square方法的参数x。x是Square()方法的局部变量，该局部变量在方法返回时被丢弃。因此，实际上并没有更改a变量中值。程序输出结果为3.

(3)方法的参数传递之引用传递

当变量通过引用传递时，方法接收到的是对实际变量数值的引用。因此在方法中对这个变量的任何更改都将改变原来的变量。通过使用ref关键字声明引用参数。一但在参数列表中使用了关键字ref，编译器就知道相应变量的数字通过引用来传递。如以下代码所示：

class Program
{
    static void Main(string[]args)
    {
        int b=4;
        Square(ref b);
        Console.WriteLine(b);
        Console.ReadLine();
    }
    static void Square(ref int x)
    {
        x=x*x;
    }
}

　　调用Square()方法时，因为使用了ref关键字，所以变量b以引用方式传递给Square方法的参数x。Square()方法对x变量进行了更改，也就是对变量b进行了更改。程序输出结果为16.

5：方法的重载

C#语言允许多个方法使用相同的名称，只要每个方法拥有不同的参数列表即可。这样定义方法的形式称为方法重载。如以下代码所示：

class Program
{
    public static int Add(int i,int j)
   {
        return(i+j);
    }
    public static double Add(double x,double y)
    {
        return(x+y);
    }
    public static string Add(string s1,string s2)
    {
        return(s1+s2);
    }
    static void Main(string[]args)
    {
        Console.WriteLine(Add(1,2));
        Console.WriteLine(Add(1.5,2.5));
        Console.WriteLine(Add("Hello","world"));
        Console.ReadLine();
    }
 
}

　　当程序中的一个重载方法被调用时，C#编译器通过检查调用者使用的参数的数目、类型和顺序来选择具体的方法。在上述代码中，虽然有多个Add()方法，但是每个Add()方法中参数的个数和类型不完全相同，所有系统在调用时会自动找到最匹配的方法。

和方法一样，类的构造函数也可以重载。对构造函数重载有助于以多种方式创建实例。例如：Circle类代码

public Circle()
{
    radius=0;
}
public Circle(int radius Value)
{
    radius=radius Value;
}

　　在Programs.cs中创建Circle类对象的代码如下：

double area;
Circle c1=new Circle();
area=c1.getArea();
Console.Write(c1.getRadius()+":");
Console.WriteLine(area);
Circle c2=new Circle(10);
area=c2.getArea();
Console.Write(c2.getRadius()+":");
Console.WriteLine(r);

　　当创建c1对象时，将调用与之匹配的构造函数，及Circle()。当创建c2对象时，将调用与之匹配的构造函数，即Circle(int radius Value).

6:属性

尽管使用private这样的访问修饰符可以控制对类成员的访问，但是，在C#中通过使用属性，可以更有效地管理对类成员的访问。属性是一种类成员，它可以用来控制其他对象对本对象数据的访问。

定义属性的语法形式如下：

public|protected 数据成员数据类型 属性名
{
    get{
              //获取属性的代码
         }
    set{
             //设置属性的代码
         }
}

　　例如：

建立Circle类，代码如下：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace ConsoleApplication39
{
    class Circle
    {
        private int radius;
        const double PI = 3.14;
        public Circle(int radiusValue)
        {
            CircleRadius = radiusValue;
        }
        //CircleRadius属性
        public int CircleRadius
        {
            get
            {
                return radius;
            }
            set
            {
                radius = ((value >= 0) ? value : 0);
            }
        }
        public double getArea()
 
        {
            return PI * CircleRadius * CircleRadius;
        }
    }
}

　　主程序Program中代码如下：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace ConsoleApplication39
{
    class Program
    {
        static void Main(string[] args)
        {
            Circle c = new Circle(1);
 
            c.CircleRadius = 10;
            Console.WriteLine(c.getArea());
 
            c.CircleRadius = -9;
            Console.WriteLine(c.getArea());
 
            Console.ReadLine();
        }
    }
}

　　运行结果：

通过get访问器和set访问器访问private数据，不仅防止字段接受无效值，而且也隐藏了字段的内部实现。根据情况的不同，C#语言允许只提供get访问器或者只提供set访问器，也可以同时提供get和set访问器。