ASP.NET:类的概念及类的继承,实例化,嵌套

1.类的概念

类声明定义新的引用类型。一个类可以从其它类继承，并且可以没用接口或有多个接口。
类的成员可以包括常数、域、方法、属性、索引、事件、操作符、构造函数、析构器和嵌套类型声明。每个成员有相关的访问能力，这控制了可以访问这个成员的程序文本的区域。有访问能力有五种可能形式。在下表中进行总结。
形式 直观意义
public 访问不受限制
protected 访问只限于此程序或类中包含的类型
internal 访问只限于此程序
protected internal 访问只限于此程序或类中包含的类型
private 访问只限于所包含的类型

例子
using System;
class MyClass
{
public MyClass() {
Console.WriteLine("Constructor");
}
public MyClass(int value) {
MyField = value;
Console.WriteLine("Constructor");
}
~MyClass() {
Console.WriteLine("Destructor");
}
public const int MyConstant = 12;
public int MyField = 34;
public void MyMethod(){
Console.WriteLine("MyClass.MyMethod");
}
public int MyProperty {
get {
return MyField;
}
set {
MyField = value;
}
}
public int this[int index] {
get {
return 0;
}
set {
Console.WriteLine("this[{0}] was set to {1}", index, value);
}
}
public event EventHandler MyEvent;
public static MyClass operator (MyClass a, MyClass b) {
return new MyClass(a.MyField b.MyField);
}
internal class MyNestedClass
{}
}
介绍了一个包含每种类型成员的类。例子
class Test
{
static void Main() {
// Constructor usage
MyClass a = new MyClass();
MyClass b = new MyClass(123);
// Constant usage
Console.WriteLine("MyClass.MyConstant = {0}", MyClass.MyConstant);
// Field usage
a.MyField ;
Console.WriteLine("a.MyField = {0}", a.MyField);
// Method usage
a.MyMethod();
// Property usage
a.MyProperty ;
Console.WriteLine("a.MyProperty = {0}", a.MyProperty);
// Indexer usage
a[3] = a[1] = a[2];
Console.WriteLine("a[3] = {0}", a[3]);
// Event usage
a.MyEvent = new EventHandler(MyHandler);
// Overloaded operator usage
MyClass c = a b;
}
static void MyHandler(object sender, EventArgs e) {
Console.WriteLine("Test.MyHandler");
}
internal class MyNestedClass
{}
}
介绍如何使用这些成员。.
1.7.1 常数
一个常数是一个代表常数值的类成员：某个可以在编译时计算的数值。只要没有循环从属关系，允许常数依赖同一程序中的其它常数。例子
class Constants
{
public const int A = 1;
public const int B = A 1;
}
包括一个名为Constants的类，有两个公共常数。 
常数是隐式静态类型，可以通过类来访问，
class Test
{
static void Main() {
Console.WriteLine("A = {0}, B = {1}", Constants.A, Constants.B);
}
}
在此例中打印输出Constants.A和Constants.B的数值。
1.7.2 域
域是一个代表和某对像或类相关的变量的成员。例子
class Color
{
internal ushort redPart;
internal ushort bluePart;
internal ushort greenPart;
public Color(ushort red, ushort blue, ushort green) {
redPart = red;
bluePart = blue;
greenPart = green;
}
...
}
介绍了一个Color类，它有局部的实例域，分别叫做redPart、greenPart和bluePart。域可以是静态的，在下面的例子中
class Color
{
public static Color Red = new Color(0xFF, 0, 0);
public static Color Blue = new Color(0, 0xFF, 0);
public static Color Green = new Color(0, 0, 0xFF);
public static Color White = new Color(0, 0, 0);
public static Color Black = new Color(0xFF, 0xFF, 0xFF);
...
}
介绍了Red、Blue、Green、White和Black的静态域。
静态域在这里并不太合适。当Color类被加载后，域就被初始化了，但是在初始化之后，并不能阻止用户改变它们。而那样的改动可能会引起别的使用Color并认为数值不会变的程序的不可预见的错误。只读域可以用来避免这一错误的发生。对于一个只读域的赋值，只会在相同类中的部分声明和构造函数中发生。这样，就可以通过给静态域添加只读修饰符来增强Color类：
class Color
{
internal ushort redPart;
internal ushort bluePart;
internal ushort greenPart;
public Color(ushort red, ushort blue, ushort green) {
redPart = red;
bluePart = blue;
greenPart = green;
}
public static readonly Color Red = new Color(0xFF, 0, 0);
public static readonly Color Blue = new Color(0, 0xFF, 0);
public static readonly Color Green = new Color(0, 0, 0xFF);
public static readonly Color White = new Color(0, 0, 0);
public static readonly Color Black = new Color(0xFF, 0xFF, 0xFF);
} 


2.类的继承

学生可以看成一个对象,班级也可以看成一个对象,只是他们之间没有任何联系. 

但是你可以把学生作为一个大的对象,里面包含很多小的对象,如大学生,小学生,中学生等. 
而班级也可以做为一个大的对象,里面包含很多小的对象,如大班,小班,专业班等. 

其实可以理解为: 父类:学生-----子类:大学生 
|-子类:小学生 
|-子类:中学生 
班级一样.其实都是对象之间的关系. 
但是记住在没有任何方法(行为)和属性(特性)时,它们都是独立的.没有任何联系. 

当然你可以画个树型结构就可以知道(把他们共有特性画出来,看看有没有联系),其实当你的关系越多时,他们的联系就越紧密. 

比如: 
class 学生 
{ 
protected string name; 
protected string sex; 
protected string age; 
} 
class 张三 : 学生 
{ 
public string getname 
{ 
get 
{this.name = "张三";return this.name} 
} 
} 
以上就是一个典型的继承关系.当你构造张三时,其实就已经构造了一个学生.他的名字(属性)返回的是"张三".同理,我们可以也这样看作学生和大学生的关系,只不过不是名字,而是类型(也是一个属性). 

比如: 
class 学生 
{ 
protected string types; 
protected string sex; 
protected string age; 
} 
class 大学生 : 学生 
{ 
public string gettypes 
{ 
get 
{this.types = "大学生";return this.types} 
} 
} 
所以,他们之间的关系可以是继承的. 
同样“大学”和“清华大学”之间是继承关系. 
当然我可以具体的告诉你“大学”和“清华大学”之间是多继承关系.在JAVA中不用继承实现,而用接口实现. 


3.类的实例化及嵌套

class OutClass 
{ 
public OutClass() //A 
{ 
Console.WriteLine("Instance OutClass"); 
} 
class InnerClass 
{ 
public InnerClass() 
{ 
Console.WriteLine("Instance InnerClass"); 
} 
} 
} 

定义了2个类 其中InnerClass为嵌套类 
程序入口如下 
Class Test 
{ 
public static void Main() 
{ 
OutClass myClass = new OutClass(); 
} 
} 

输出结果如下: 
Instance OutClass 
Please any key to continue 
此段程序说明当你实例化外边的类OutClass时，编译器并没有自动实例化里边的嵌套类 


可以在OutClass构造函数里添加InnerClass的实例来实例化里边的嵌套类 
对//A作如下修改 
public OutClass() //A 
{ 
Console.WriteLine("Instance OutClass"); 
InnerClass myInnerClass = new InnerClass; //B 
} 
通过添加//B 行的代码才能实例化里边的嵌套类InnerClass;