C# 开发 —— 数组类对象接口

数组类型是从抽象基类 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("
");
            }
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("	 键	 值");
            //遍历Hashtable哈希表中的元素并输出其键值对
            foreach (DictionaryEntry dicEntry in hashtable)
            {
                Console.WriteLine("	 " + dicEntry.Key + "	 " + 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("编号	 姓名");
            Console.WriteLine(ID + "	 " + 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一起使用