数组类型是从抽象基类 Array 派生的引用类型，通过new运算符创建数组并将数组元素初始化为他们的默认值
一维数组
type[] arrayname;
数组的长度不是声明的一部分，而且数组必须在访问前初始化。
foreach 语句声明一个迭代变量 —— 是数组的每个元素的只读副本
二维数组
type[,] arrayName;
int[,] arr = new int[2,2]{{1,2},{3,4}};
可使用数组的Rank属性和GetUpperBound方法获取数组的行数和列数，然后遍历数组
for (int i = 0; i < arr.Rank; i++)
{
string str = "";
for (int j = 0; j < arr.GetUpperBound(arr.Rank - 1) + 1; j++)
{
str = str + Convert.ToString(arr[i, j]) + " "; //循环输出二维数组中的每个元素
}
Console.Write(str);
Console.Write("\n");
}
int row = Convert.ToInt32(Console.ReadLine()); //定义动态数组的行数数组排序
Array.Sort 对一维Array中的数组中元素进行排序，Array.Reverse 用于反转一维Array数组或部分Array数组中元素的顺序
ArrayList 类
位于 System.Collections 命名空间下，可以动态地添加和删除元素
容量可根据需要自动扩充
添加，删除，插入某一范围元素的方法
提供将只读和固定大小包装返回到集合的方法
ArrayList只能是一维形式
可用数组构造ArrayList
Add（）
Insert（）
Clear（） Remove（Object） RemoveAt（int） RemoveRange
Contains （） —— 是否包含
Hashtable 哈希表
Add Clear Remove Contains ContainsValue
Hashtable hashtable = new Hashtable(); //实例化Hashtable对象
hashtable.Add("id", "BH0001"); //向Hashtable哈希表中添加元素
hashtable.Add("name", "TM");
hashtable.Add("sex", "男");
Console.WriteLine("\t 键\t 值");
//遍历Hashtable哈希表中的元素并输出其键值对
foreach (DictionaryEntry dicEntry in hashtable)
{
Console.WriteLine("\t " + dicEntry.Key + "\t " + dicEntry.Value);
}
Console.WriteLine();属性访问器 ： get ，set
属性不能作为ref参数或out参数传递
自定义属性的声明方式 ： 指定属性的访问级别，属性的类型，属性的名称
class MyClass
{
private string id = ""; //定义一个string类型的变量，用来记录用户编号
/// <summary>
///定义用户编号属性，该属性为可读可写属性
/// </summary>
public string ID
{
get
{
return id;
}
set
{
id = value;
}
}
private string name = ""; //定义一个string类型的变量，用来记录用户姓名
/// <summary>
///定义用户姓名属性，该属性为只读属性
/// </summary>
public string Name
{
get
{
return name;
}
}
}属性的使用 ： 对象名.属性名
一个方法的名称和形参列表（形参的个数，修饰符，类型）定义了该方法的签名
返回类型和形参名称不是方法签名的组成部分
静态方法
不对特定实例进行操作，在静态方法中引用 this 会编译错误
方法的重载
同一方法名，单方法中参数的数据类型，个数或顺序不同
Main 是程序的入口点，唯一
main 方法默认访问级别是private
结构
将多个相关的变量包装成为一个整体使用
结构是值的类型
向方法传递结构时，结构是通过值传递方式传递的，而非引用传递
结构的实例化可以不使用new
在结构中初始化实例字段是错误的
class Program
{
public struct Rect //定义一个矩形结构
{
public double width; //矩形的宽
public double height; //矩形的高
public Rect(double x, double y)
{
width = x;
height = y;
}
public double Area()
{
return width * height;
}
}
static void Main(string[] args)
{
Rect rect1; //实例化矩形结构
rect1.width = 5; //为矩形宽赋值
rect1.height = 3; //为矩形高赋值
Console.WriteLine("矩形面积为：" + rect1.Area());
Rect rect2 = new Rect(6, 4); //使用构造函数实例化矩形结构
Console.WriteLine("矩形面积为：" + rect2.Area());
}
}类
类定义可以在不同的源文件之间进行拆分
继承类时，需要使用冒号加类名。当对一个类应用 sealed 修饰符时，该修饰符会组织其他类从该类继承
virtual 修饰符不能与 private，static ，abstract 或者 override修饰符同时使用
override 修饰符不能与 new ，static ，或者 virtual 修饰符同时使用，并且重写方法只能用于重写基类中的虚函数
C#，继承，虚方法和重写方法组合在一起才能实现多态性
接口
C# 类不支持多重继承
接口不包含方法的实现
namespace Test02
{
interface ImyInterface
{
string ID
{
get;
set;
}
string Name
{
get;
set;
}
void ShowInfo();
}
class Program:ImyInterface//继承自接口
{
string id = "";
string name = "";
public string ID
{
get
{
return id;
}
set
{
id = value;
}
}
public string Name
{
get
{
return name;
}
set
{
name = value;
}
}
public void ShowInfo()
{
Console.WriteLine("编号\t 姓名");
Console.WriteLine(ID + "\t " + Name);
}
static void Main(string[] args)
{
Program program = new Program(); //实例化Program类对象
ImyInterface imyinterface = program; //使用派生类对象实例化接口ImyInterface
imyinterface.ID = "TM"; //为派生类中的ID属性赋值
imyinterface.Name = "C# 2.0从入门到应用开发"; //为派生类中的Name属性赋值
imyinterface.ShowInfo(); //调用派生类中方法显示定义的属性值
}
}
}显式接口成员实现
一个类实现了两个接口，并且这两个接口包含具有相同签名的成员
namespace Test03
{
interface ImyInterface1
{
int Add();
}
interface ImyInterface2
{
int Add();
}
class myClass : ImyInterface1, ImyInterface2 //继承接口
{
int ImyInterface1.Add() //显式接口成员实现
{
int x = 3;
int y = 5;
return x + y;
}
int ImyInterface2.Add() //显式接口成员实现
{
int x = 3;
int y = 5;
int z = 7;
return x + y + z;
}
}
class Program
{
static void Main(string[] args)
{
myClass myclass = new myClass(); //实例化接口继承类的对象
ImyInterface1 imyinterface1 = myclass; //使用接口继承类的对象实例化接口
Console.WriteLine(imyinterface1.Add()); //使用接口对象调用接口中的方法
ImyInterface2 imyinterface2 = myclass; //使用接口继承类的对象实例化接口
Console.WriteLine(imyinterface2.Add()); //使用接口对象调用接口中的方法
}
}
}抽象类与抽象方法
抽象类不能直接实例化
抽象类不能被密封 sealed
namespace Test04
{
public abstract class myClass
{
private string id = "";
private string name = "";
public string ID
{
get
{
return id;
}
set
{
id = value;
}
}
public string Name
{
get
{
return name;
}
set
{
name = value;
}
}
public abstract void ShowInfo();
}
public class DriveClass : myClass //继承抽象类
{
public override void ShowInfo()
{
Console.WriteLine(ID + " " + Name);
}
}
class Program
{
static void Main(string[] args)
{
DriveClass driveclass = new DriveClass(); //实例化派生类
myClass myclass = driveclass; //使用派生类对象实例化抽象类
myclass.ID = "BH0001"; //使用抽象类对象访问抽象类中的编号属性
myclass.Name = "TM"; //使用抽象类对象访问抽象类中的姓名属性
myclass.ShowInfo(); //使用抽象类对象调用派生类中的方法
}
}
}密封类密封方法
用来限制扩展性
不能被作为基类继承，但可以继承别的类或接口
不能与abstract一起使用
