数组类型是从抽象基类 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一起使用