C#个人总结，第三章：对象和类型

1. 类和结构

（1）类和结构实际上都是创建对象的模板，每个对象都包含数据,并提供了处理和访问数据的方法。

（2）类定义了类的每个对象(称为实例)可以包含什么数据和功能。

（3）结构与类的区别是它们在内存中的存储方式、访问方式(类是存储在堆（heap）上的引用类型,而结构是存储在栈（stack）上的值类型)和它们的一些特征(如结构不支持继承。

（4）结构struct，类Class

2. 类

（1）类中的数据和函数称为类的成员。成员的可访问性可以是public、protected、internal protected、private或internal

2.1 数据成员

（1）数据成员是包含类的数据——字段、常量和事件的成员。数据成员可以是静态数据。类成员总是实例成员,除非用static进行显式的声明。

2.2 函数成员

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

2.2.1 方法

（1）方法的声明

（2）调用方法：代码：

namespace study3_2_2_1
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Pi is " + MathTest.GetPi());
            int x = MathTest.GetSquareOf(5);
            Console.WriteLine("Square of 5 is " + x);

            MathTest math = new MathTest();

            math.value = 30;
            Console.WriteLine("Value field of math variable contains " + math.value);
            Console.WriteLine("Square of 30 is " + math.GetSquare());
        }
    }

    class MathTest
    {
        public int value;

        public int GetSquare()
        {
            return value * value;
        }

        public static int GetSquareOf(int x)
        {
            return x * x;
        }

        public static double GetPi()
        {
            return 3.14159;
        }
    }
}

结果：

（3）给方法传递参数：int通过值传递给方法,对应方法对该int的值所做的任何改变都没有改变原int对象的值。但如果把数组或其他引用类型（如类)传递给方法,对应的方法就会使用该引用改变这个数组中的值,而新值会反射在原始数组对象上。

代码：

namespace study3_2_2_5
{
    class Program
    {
        static void SomeFunction(int[] ints, int i)
        {
            ints[0] = 100;
            i = 100;
        }
        static void Main(string[] args)
        {
            int i = 0;
            int[] ints = { 0,1,2,4,8};

            Console.WriteLine("i = " + i);
            Console.WriteLine("ints[0] = " + ints[0]);
            Console.WriteLine("Calling SomeFunction.");

            SomeFunction(ints, i);

            Console.WriteLine("i = " + i);
            Console.WriteLine("ints[0] = " + ints[0]);
        }
    }
}

结果：

（4）ref参数：迫使值参数通过引用传送给方法。

（5）out参数：传递给该方法的变量可以不初始化。

（6）命名参数：参数一般需要按定义的顺序传送给方法。命名参数允许按任意顺序传递。

（7）可选参数：参数也可以是可选的。必须为可选参数提供默认值。可选参数还必须是方法定义的最后一个参数。

（8）方法的重载：方法的几个版本有不同的签名(即：方法名相同,但参数的个数（和/或）类型不同)。限制：两个方法不能仅在返回类型上有区别； 两个方法不能仅根据参数是声明为ref还是out来区分。

2.2.2 属性：属性（property）的概念是：它是一个方法或一对方法，在客户端代码看来，它（们）是一个字段。

（1）只读和只写属性：在属性定义中省略set访问器,就可以创建只读属性。同样,在属性定义中省略get访问器,就可以创建只写属性。

（2）属性的访问修饰符：属性可以有公有的get访问器和私有或受保护的set访问器。

（3）自动实现的属性：

（4）内联：

2.2.3 构造函数：

（1）声明基本构造函数的语法就是声明一个与包含的类同名的方法,但该方法没有返回类型。

（2）构造函数的重载遵循与其他方法相同的规则。

（3）如果提供了带参数的构造函数,编译器就不会自动提供默认的构造函数。只有在没有定义任何构造函数时,编译器才会自动提供默认的构造函数

2.2.3.1 静态构造函数：

（1）C#的一个新特征是也可以给类编写无参数的静态构造函数。这种构造函数只执行一次,而前面的构造函数是实例构造函数,只要创建类的对象,就会执行它。

（2）编写静态构造函数的一个原因是,类有一些静态字段或属性,需要在第一次使用类之前,从外部源中初始化这些静态字段和属性。

（3）注意,无参数的实例构造函数与静态构造函数可以在同一个类中同时定义。

（4）代码：

namespace study3_2_2_3
{
    public class UserPreferences
    {
        public static readonly Color BackColor;

        static UserPreferences()
        {
            DateTime now = DateTime.Now;
            if (now.DayOfWeek == DayOfWeek.Thursday || now.DayOfWeek == DayOfWeek.Wednesday)
            {
                BackColor = Color.Green;
            }
            else
            {
                BackColor = Color.Red;
            }
        }

        private UserPreferences()
        {

        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("User-preferences:BackColor is: " +
                UserPreferences.BackColor.ToString());
        }
    }
}

（5）结果：

2.2.3.2 从构造函数中调用其他构造函数

（1）C#有一个特殊的语法,称为构造函数初始化器。

（2）这里this关键字仅调用参数最匹配的那个构造函数。注意,构造函数初始化器在构造函数的函数体之前执行。

2.3 只读字段

（1）readonly关键字比const灵活得多,允许把一个字段设置为常量,但还需要执行一些计算,以确定它的初始值。

（2）其规则是可以在构造函数中给只读字段赋值,但不能在其他地方赋值。只读字段还可以是一个实例字段,而不是静态字段,类的每个实例可以有不同的值。与const字段不同,如果要把只读字段设置为静态,就必须显式声明它。

3. 匿名类型

（1）var关键字,用于表示隐式类型化的变量。var与new关键字一起使用时,可以创建匿名类型。匿名类型只是一个继承自Object 且没有名称的类。该类的定义从初始化器中推断,类似于隐式类型化的变量。

（2）var captain = new (FirstName = "James", MiddleName = "T", LastName = "Kirk");

4. 结构

（1）有时仅需要一个小的数据结构。此时,类提供的功能多于我们需要的功能,由于性能原因,最好使用结构。

（2）为结构定义函数与为类定义函数完全相同

（3）结构是值类型,不是引用类型。它们存储在栈中或存储为内联。

（4）结构不支持继承；对于结构构造函数的工作方式有一些区别。尤其是编译器总是提供一个无参数的默认构造函数,它是不允许替换的；使用结构,可以指定字段如何在内存中的布局。

4.1 结构是值类型

（1）虽然结构是值类型,但在语法上常常可以把它们当作类来处理。

（2）因为结构是值类型,所以New运算符与类和其他引用类型的工作方式不同。New运算符并不分配堆中的内存,而是只调用相应的构造函数,根据传送给它的参数,初始化所有的字段。对于结构,变量声明实际上是为整个结构在栈中分配空间,所以就可以为它赋值了。

（3）结构遵循其他数据类型都遵循的规则:在使用前所有的元素都必须进行初始化。在结构上调用new运算符,或者给所有的字段分别赋值,结构就完全初始化了。当然,如果结构定义为类的成员字段,在初始化包含的对象时,该结构会自动初始化为0。

（4）结构主要用于小的数据结构。但当把结构作为参数传递给方法时,应把它作为ref参数传递,以避免性能损失——此时只传递了结构在内存中的地址,这样传递速度就与在类中的传递速度工样快了。但如果这样做,就必须注意被调用的方法可以改变结构的值。

4.2 结构和继承

（1）结构不支持继承。

4.3 结构的构造函数

（1）为结构定义构造函数的方式与为类定义构造函数的方式相同,但不允许定义无参数的构造函数。

5. 部分类

（1）partial关键字允许把类、结构或接口放在多个文件中。编译时，只会生成一个类，而类中有各个文件中的方法。

6. 静态类

（1）如果类只包含静态的方法和属性，该类就是静态的。静态类在功能上与使用私有静态构造函数创建的类相同。不能创建静态类的实例。使用static关键字。

7. Object类

7.1 System.Object（）方法

• ToString（）
• GetHashtable（）
• Equals（）和ReferenceEquals（）
• Finalize（）
• GetType（）
• MemberwiseClone（）

7.2 ToString（）

（1）代码：

namespace study3_7_2
{
    class Program
    {
        static void Main(string[] args)
        {
            Money cash1 = new Money();
            cash1.Amount = 40M;
            Console.WriteLine("cash1.ToString() returns:" + cash1.ToString());
            Console.ReadLine();
        }
    }

    public class Money
    {
        private decimal amount;

        public decimal Amount
        {
            get { return amount; }
            set { amount = value; }
        }

        public override string ToString()
        {
            return "$"+Amount.ToString();
        }
    }
}

（2）结果：

8. 扩展方法

（1）扩展方法,允许改变一个类,但不需要该类的源代码。扩展方法是静态方法。

（2）对于扩展方法,第一个参数是要扩展的类型,它放在this关键字的后面。这告诉编译器,这个方法是Money类型的一部分。

（3）在主程序中,扩展方法看起来像是另一个方法。它没有显示第一个参数,也不能对它进行任何处理。如：

public statio class MoneyExtension
{
public static void AddToAmount(this MOney money, decimal amountToAdd)
{
money.Amount += amountToAdd;
}
}

主：cash1.AddToAmount(10M);