类和结构
类和结构实际上都是创建对象的模板,每个对象都包含数据,并提供了处理和访问数据的方法。
类是存储在堆(heap)上的引用类型,而结构是存储在堆栈(stack)上的值类型。较小的数据类型使用结构可提高性能。但在语法上,结构与类非常相似,主要的区别是使用关键字struct代替class来声明结构。在大多数情况下,类要比结构常用得多。
类:
class PhoneCustomer
{
public const string DayOfSendingBill ="Monday";
public int CustomerID;
public string FirstName;
public string LastName;
}
结构:
struct PhoneCustomerStruct
{
public const string DayOfSendingBill = "Monday";
public int CustomerID;
public string FirstName;
public string LastName;
}
对于类和结构,都使用关键字new来声明实例:这个关键字创建对象并对其进行初始化。
PhoneCustomer myCustomer = new PhoneCustomer(); //works for a class
PhoneCustomerStruct myCustomer2 = new PhoneCustomerStruct(); // works for a struct
一.类的封装:
1.数据成员: 字段、常量和事件。
数据成员可以是静态数据或实例数据。不做特殊说明时,类成员总是实例成员,除非用static进行了显式的声明。
静态成员属于类的,在所有的对象中都使用一个存储空间
实例成员属于对象的,在每一个对象中都使用一个独立的存储空间
2.函数成员:函数成员提供了操作类中数据的某些功能,包括方法、属性、构造函数和终结器(finalizor)、运算符以及索引器。
(1)方法
a.方法的声明
[modifiers] return_type MethodName([parameters])
{
// Method body
}
如果方法没有返回值,就把返回类型指定为void,因为不能省略返回类型。
b.调用方法
函数名(实参列表);
c.给方法传递参数
ref关键字:迫使值参数通过引用传送给方法。如果把一个参数传递给方法,且这个方法的输入参数前带有ref关键字,则该方法对变量所作的任何改变都会影响原来对象的值。
在调用该方法时,还需要添加ref关键字:
SomeFunction(ints, ref i);
out关键字:使函数能从函数内向函数外输出多个值。当在方法的输入参数前面加上out关键字时,传递给该方法的变量可以不被初始值初始化。
在调用该方法时,还需要添加out关键字:
SomeFunction(out i);
方法的重载:方法名相同,但参数个数与参数类型不同。不能够根据方法的返回值形成重载。
(2)属性
用来给成员变量赋值与取值的功能。
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部分的属性称为只写属性
不能在get或set之间加访问修饰符
(3).构造函数
如果没有显式地提供任何构造函数,编译器会在后台创建一个默认的构造函数。
构造函数没有返回类型,且函数名与类名同名。
构造函数可以形成重载。
静态构造函数:可以给类编写无参数的静态构造函数。这种构造函数只执行一次,而前面的构造函数是实例构造函数,只要创建类的对象,它都会执行。类有一些静态字段或属性,需要在第一次使用类之前,从外部源中初始化这些静态字段和属性。
注意:
静态构造函数没有定义访问修饰符,总是由.NET运行库调用它,所以像public 和 private这样的访问修饰符就没有意义了。
静态构造函数不能带有任何参数
一个类也只能有一个静态构造函数
静态构造函数只能访问类的静态成员,不能访问实例成员。
无参数的实例构造函数可以在类中与静态构造函数安全共存。尽管参数列表是相同的,但这并不矛盾。因为静态构造函数是在加载类时执行,而实例构造函数是在创建实例时执行。
如果多个类都有静态构造函数,先执行哪个静态构造函数是不确定的。
从其他构造函数中调用构造函数:
class Car
{
private string description;
private uint nWheels;
public Car(string model, uint nWheels)
{
this.description = description;
this.nWheels = nWheels;
}
public Car(string model) : this(model, 4)//构造函数初始化器
{
}
}
在本例中,在带有一个参数的构造函数执行之前,先执行带2个参数的构造函数
(4)只读字段
只读字段readonly类似于const常量,但与常量又有所不同。const常量在定义的时候就必须对它进行赋初值,在以后的使用过程中是不许进行改变的,而readonly形的变量在定义的时候可以不赋值,而在构造函数中对它进行初始化值,一旦赋值后就不可再更改其值,它类似于java中的final型的变量。
readonly关键字比const灵活得多,允许把一个字段设置为常量,但在将字段设为常量之前可以执行一些运算,以指定它的初始值。
在构造函数中给readonly字段赋值,但不能在其他地方赋值
readonly字段还可以是一个实例字段,而不是静态字段,类的每个实例可以有不同的值
如果要把readonly字段设置为静态,就必须使用static关键字进行显式声明;
在构造函数中未给readonly 字段赋值,它的值就是其数据类型的默认值
public class Document
{
public readonly DateTime CreationDate;
public Document()
{
CreationDate = new DateTime(2002, 1, 1);
}
}
二、类的继承
C#不支持多重实现继承。而C#却允许类型派生于多个接口。因为System.Object是一个公共的基类,所以每个C#类(除了Object类之外)都有一个基类,还可以有任意多个基接口。
(1)类的继承语法:
class MyDerivedClass : MyBaseClass
{
// functions and data members here
}
(2)虚方法
把一个基类函数声明为virtual,该函数就可以在任何派生类中重写了,否则默认基类中的函数是无法被重写的。也可以把属性声明为virtual。
class MyBaseClass
{
public virtual string VirtualMethod()
{
return "This method is virtual and defined in MyBaseClass";
}
public virtual string ForeName
{
get { return foreName; }
set { foreName = value; }
}
private string foreName;
}
在C#中,函数在默认情况下不是虚拟的,但(除了构造函数以外)可以显式地声明为虚拟。而在Java中,所有的函数都是虚拟的。
在派生类的函数重写另一个函数时,要使用override关键字显式声明:
class MyDerivedClass : MyBaseClass
{
public override string VirtualMethod()
{
return "This method is an override defined in MyDerivedClass";
}
}
(3)隐藏方法
如果签名相同的方法在基类和派生类中都进行了声明,但该方法没有声明为virtual 和 override,派生类方法就会隐藏基类方法。
成员字段和静态函数都不能被声明为virtual,因为这个概念只对类中的实例函数成员有意义。
如果签名相同的方法在基类和派生类中都进行了声明,但该方法没有声明为virtual 和 override,派生类方法就会隐藏基类方法。结果是调用哪个类的方法取决于用于引用实例的变量类型,而不是实例本身的类型。
系统会发出警告。在C#中,应使用new关键字声明我们要隐藏一个方法。
(4)调用函数的基础版本
从派生类中调用方法的基础版本:base.<MethodName>()。
class CustomerAccount
{
public virtual decimal CalculatePrice()
{
// implementation
return 0.0M;
}
}
class GoldAccount : CustomerAccount
{
public override decimal CalculatePrice()
{
return base.CalculatePrice() * 0.9M;
}
}
可以使用base.<MethodName>()语法调用基类中的任何方法,不必是在同一个方法的重载中调用它。
(5)抽象类和抽象函数
抽象类不能实例化,而抽象函数没有执行代码,必须在非抽象的派生类中重写。
如果类包含抽象函数,该类将也是抽象的,也必须声明为抽象的:
abstract class Building
{
public abstract decimal CalculateHeatingCost(); // abstract method
}
(6)密封类和密封方法
把类和方法声明为sealed,对于类来说,这表示不能继承该类,对于方法来说;这表示不能重写该方法。
类似于Java中的final。
sealed class FinalClass
{
// etc
}
class DerivedClass : FinalClass // 错误:密封类无法被继承
{
// etc
}
在方法上使用sealed关键字是没有意义的,如果定义一个新方法,但不想让别人重写它,不要把它声明为virtual就可以了。
(7)派生类的构造函数(车延禄)
基类的构造函数总是最先调用。也就是说,派生类的构造函数可以在执行过程中调用基类方法、属性和其他成员,因为基类已经构造出来的,其字段也初始化了。
a.无参数的构造函数
b.有参数的构造函数
使用在子类构造函数之后使用base关键字调用父类构造函数,并传递构造实参
三、可见性修饰符
不能把类型定义为protected、internal和protected internal,这些修饰符只能应用于成员。
四、其他修饰符
五、接口
接口中只能包含方法、属性、索引器和事件的声明。
不能实例化接口,接口不能有构造函数或字段。
在接口定义中还不允许声明成员上的修饰符。接口成员总是公共的,不能声明为虚拟或静态。
1.定义和实现接口
public interface IBankAccount
{
void PayIn(decimal amount);
bool Withdraw(decimal amount);
decimal Balance
{
get;
}
}
接口名称传统上以字母I开头,以便知道这是一个接口。(车延禄)
2.接口的派生
public interface ITransferBankAccount : IBankAccount
{
bool TransferTo(IBankAccount destination, decimal amount);
}
六、结构
类在实例化过程中会在堆中创建对象,但性能会有一定的损失。有时仅需要一个小的数据结构,为了实现性能的优化我们可以使用结构替代类。
结构是值类型,不是引用类型。它们存储在堆栈中。
结构不支持继承。
结构中可以有方法。
结构有构造函数,编译器总是提供一个无参数的默认构造函数,这是不允许替换的。
结构可以实现接口。
结构定义
struct Dimensions
{
public double Length;
public double Width;
Dimensions(double length, double width)
{ Length= length; Width= width; }
public int Diagonal
{
{
get
{
return Math.Sqrt(Length* Length + Width* Width);
}
}
}
}
使用结构
Dimensions point = new Dimensions();
point.Length = 3;
point.Width = 6;
因为结构是值类型,所以new运算符与类和其他引用类型的工作方式不同。new运算符并不分配堆中的内存,而是调用相应的构造函数,根据传送给它的参数,初始化所有的字段。