c#2(类的成员)

类的成员: 类中的数据和函数称为类的成员, 类还可以包含嵌套的类型(例如其他类)

a.数据成员包含了类的数据-- 字段、常量和事件

b.函数成员提供了操作类中数据的某些功能，包括方法、属性、构造函数和终结器(finalizer)、运算符以及索引器。

访问修饰符用于指定类成员的可访问性，有private、protected、public和internal4种。

1、局部变量：在for、switch等语句中和类方法中定义的变量，只在指定范围内有效。

2、字段：即类中的变量或常量，包括静态字段、实例字段、常量和只读字段。

3、方法成员：包括静态方法和实例方法。

4、属性：按属性指定的get方法和Set方法对字段进行读写。属性本质上是方法。

5、事件：代表事件本身，同时联系事件和事件处理函数。

6、索引指示器：允许象使用数组那样访问类中的数据成员。

7、操作符重载：采用重载操作符的方法定义类中特有的操作。

8、构造函数和析构函数。

包含有可执行代码的成员被认为是类中的函数成员，这些函数成员有方法、属性、索引指示器、操作符重载、构造函数和析构函数。

 

字段：静态字段、实例字段、常量和只读字段

常量字段: 必须赋初值，任何时候都不能改，调用Test.intMax

静态字段: 类生成多个对象或根本无对象，该字段都只有一个实例，可以在其它函数中调用，如cnn++,调用Test..cnt

实例字段: 每创建该类的一个对象，在对象内创建一个该字段实例，创建它的对象被撤销，该字段对象也被撤销。调用T1.x

只读字段:只能在构造函数中初始化，调用T1.y

public class Test

{     public const int intMax=int.MaxValue;//常量

public int x=0;//实例字段

public readonly int y=0;//只读字段

public static int cnt=0;//静态字段

public Test(int x1,int y1)//构造函数

{     //intMax=0;//错误，不能修改常量

       x=x1;//在构造函数允许修改实例字段

       y=y1;//在构造函数允许修改只读字段

       cnt++;//每创建一个对象都调用构造函数，用此语句可以记录对象的个数

}

public void Modify(int x1,int y1)

{     //intMax=0;//错误，不能修改常量

    x=x1;

    cnt=y1;

    //y=10;//不允许修改只读字段

}

}

class Class1

{   static void Main(string[] args)

{

    test.cnt;//无对象时可以调用

    Test T1=new Test(100,200);

    T1.x=40;//引用实例字段采用方法：实例名.实例字段名

      Test.cnt=0;//引用静态字段采用方法：类名.静态字段名

        int z=T1.y;//引用只读字段

      z=Test.intMax;//引用常量

}

}

 

方法：

方法的声明格式如下:

属性 方法修饰符 返回类型方法名(形参列表){方法体}

方法修饰符包括new、public、protected、internal、private、static、virtual、sealed、override、abstract和extern。

形参类别：

值参数，不含任何修饰符。程序给实参的值做一份拷贝，并且将此拷贝传递给该方法，如果参数类型是引用类型（如类的引用变量），则拷贝和实参引用同一个对象，通过这个拷贝，可以修改实参所引用的对象中的数据成员。(字符串不行)

引用参数，以ref修饰符声明。

输出参数，以out修饰符声明。传递给该方法的变量可以不初始化

数组参数，以params修饰符声明。

static void F(params int[] args)//数组参数，有params说明

    {   Console.Write("Array contains {0} elements:",args.Length);

        foreach (int i in args)

Console.Write(" {0}",i);

        Console.WriteLine();

    }

F(10, 20, 30, 40);//等价于F(new int[] {60,70,80,90});

F();//等价于F(new int[] {});

F(new int[] {});//实参为数组类引用，数组无元素

扩展方法：为类Money扩展了方法AddToAmount(decimal amountToAdd)

static class MoneyExtension

    {

        public static void AddToAmount(this Money money, decimal amountToAdd)

        {

            money.Amount += amountToAdd;

        }

    }

调用：

Money cash1 = new Money();

cash1.AddToAmount(10);

属性：

<1>定义属性：

private string foreName;

public string ForeName
{
    get
    {
        return foreName;
    }

set

{

if (value.Length > 20)
// code here to take error recovery action
// (eg. throw an exception)
else
foreName = value;

}
}

get访问器不带参数，且必须返回属性声明的类型。也不应为set访问器指定任何显式参数，但编译器假定它带一个参数，其类型也与属性相同，并表示为value。

<2>自动实现的属性

如果属性的set和get访问器中没有任何逻辑，就可以使用自动实现的属性。这种属性会自动实现基础成员变量。上例的代码如下：

public string ForeName {get; set;}

不需要声明private string foreName。编译器会自动创建它。(其它地方不能直接用foreName)

使用自动实现的属性，就不能在属性设置中进行属性的有效性验证，且必须有两个访问器get和set，每个访问器的访问级别可以不同public string ForeName {get; private set;}

构造函数

<1>如果没有提供任何构造函数，编译器会在后台创建一个默认的构造函数。这是一个非常基本的构造函数，它只能把所有的成员字段初始化为标准的默认值(例如，引用类型为空引用，数字数据类型为0，bool为false)。注：如果提供了带参数的构造函数，编译器就不会自动提供默认的构造函数

<2>this的使用（代表对象的引用，不能用this.i）

public class MyNumber
{

private static int i=0;
     private int number;
     public MyNumber(int number)  
     {
          this.number = number;
     }
}

<3>静态构造函数(对应于一般的实例构造函数)

一个类也只能有一个静态构造函数。静态构造函数只能访问类的静态成员，不能访问实例成员。无参数的实例构造函数可以在类中与静态构造函数安全共存，静态构造函数是在加载类时执行，而实例构造函数是在创建实例时执行，所以构造函数的执行不会有冲突。

public class UserPreferences

    {

        public static readonly Color BackColor;

        static UserPreferences()

        {

            DateTime now = DateTime.Now;

            if (now.DayOfWeek == DayOfWeek.Saturday

            || now.DayOfWeek == DayOfWeek.Sunday)

                BackColor = Color.Green;

            else

                BackColor = Color.Red;

        }

        private UserPreferences()//不能实例化

        {

        }

    }

调用：UserPreferences.BackColor.ToString()

<4>从其他构造函数中调用构造函数(this关键字仅调用参数最匹配的那个构造函数。)

class Car

    {

        private string description;

        private uint nWheels;

        public Car(string description, uint nWheels)

        {

            this.description = description;

            this.nWheels = nWheels;

        }

        public Car(string description)

            : this(description, 4)

        {

        }

    }

索引器：通过索引方式方便地访问类的数据成员的方法。

class Team

    {

        private string[] s_name = new string[2];//定义字符串数组，记录小组人员姓名

        public string this[int nIndex]//索引指示器声明，this为类Team类的对象

        {

            get//用对象名[索引]得到记录小组人员姓名时，调用get函数

            {

                return s_name[nIndex];

            }

            set//用对象名[索引]修改记录小组人员姓名时，调用set函数

            {

                s_name[nIndex] = value;//value为被修改值

            }

        }

    }

    class Test1

    {

        public static void Main()

        {

            Team t1 = new Team();

            t1[0] = "张三";

            t1[1] = "李斯";

            Console.WriteLine("{0}，{1}", t1[0], t1[1]);

        }

    }

操作符重载:

static public 函数返回类型 operator 重新定义的操作符(形参表)

class Complex//复数类定义

    {

        private double Real;//复数实部

        private double Imag;//复数虚部

        public Complex(double x, double y)//构造函数

        {

            Real = x;

            Imag = y;

        }

        static public Complex operator +(Complex a, Complex b)//重载二元操作符加号

        { return (new Complex(a.Real + b.Real, a.Imag + b.Imag)); }

        public void Display()

        { Console.WriteLine("{0}+({1})j", Real, Imag); }

    }

    class test1

    {

        static void Main(string[] args)

        {

            Complex x = new Complex(1.0, 2.0);

            Complex y = new Complex(3.0, 4.0);

            Complex z;

            z = x + y;//即z=opeator+(x,y)

            z.Display();//显示：4+(6)j

        }

    }