C#语法复习3

第七章 类与继承

1、虽然派生类不能删除基类的的任何成员，但我们可以利用在派生类当中声明与基类成员名称相同的成员来屏蔽基类成员。这叫 覆盖。

一种是隐式屏蔽。一种是显式屏蔽。所谓 显式就是 加上一个new 关键字即可。此new 可以放在字段前面，也可以放在方法前面。

此时，如果我们还是想访问基类成员，可以使用基类访问方式实现。base. Xxxx 来实现 访问隐藏的继承成员。

2、虚方法与覆写方法

这部分内容和C++里面的 虚函数与抽象类类似，而含有纯虚函数的类属于抽象类。

这里面有个神奇的地方是，使用基类的引用竟然可以访问派生类的方法。

3、构造函数的执行

初始化实例成员----- 调用基类的构造函数 ------ 执行实例构造函数的方法体。

4、类访问修饰符

Public internal

成员访问修饰符

Public private protected internal protected internal.

Public: 共有类的公有成员对同一程序集和不同程序集的所有类都是可见的。

Private：任何类的私有成员只对它自己的类或者嵌套类的成员可见。

Protected ：

Internal：

Protected internal：

5、抽象类

与抽象类相同，还有抽象方法，抽象属性，相当于纯虚函数一样。

1.     class SomeClass
2.     {
3.         public string field1 = "some class field";
4.         int myint = 5;
5.         virtual public int MyProperty
6.         {
7.             get { return myint; }
8.         }
9.         virtual public void Method1(string value)
10.         {
11.             Console.WriteLine("{0}", value);
12.         }
13.     }
14.     class OtherClass : SomeClass //继承
15.     {
16.         new public string field1 = "Other class field"; //成员的覆盖
17.         int myint = 10;
18.         //new public void Method1(string value) //方法的屏蔽
19.         //{
20.         // Console.WriteLine("{0}", value);
21.         //}
22.         override public void Method1(string value) //方法的覆盖
23.         {
24.             Console.WriteLine("{0}", value);
25.         }
26.         override public int MyProperty
27.         {
28.             get { return myint; }
29.         }
30.         public void Print()
31.         {
32.             Console.WriteLine("{0}", base.field1);//即使基类成员和方法被派生类覆盖，我们也可以
33.                                                  //使用基类访问来调用基类的成员和方法。
34.         }
35.     }
36.  
37.  
38. //调用
39.    //1、派生类是相对的，所有的类都派生于object基类，只是隐藏了 : object
40.             //2、实例变量与方法的覆盖，用关键字new实现
41.             OtherClass other = new OtherClass();
42.             other.Method1(other.field1);
43.             other.Print();//使用基类访问来调用基类的成员或方法
44.             //3、使用基类的引用，通过转换引用实现
45.             SomeClass some = (SomeClass)other;//转换引用
46.             some.Method1(some.field1);
47.             //问题：派生类可以调用基类的方法，那么基类能否调用派生类的方法
48.             //可以，使用virtual和override关键字
49.             //适用与其他成员类型
50.             Console.WriteLine(other.MyProperty);
51.             Console.WriteLine(some.MyProperty);
52.             //4、构造函数初始化语句 ：this() 加在基类构造函数后面。派生类中，指明即可。or :base(s,x) 指在派生类中调用指定的基类的构造函数。
53.             //5、类访问修饰符
54.             //public （可以被系统内任何程序集中的代码访问）与 internal（这个不允许其他程序集中的类访问内部类）
55.             //6、支持程序集间的继承，利用using添加对该基类程序集的引用

1. abstract class Mybase
2.     {
3.         public int SideLength = 10; //数据成员
4.         const int TriangleSideCount = 3;
5.         abstract public void PrintStuff(string s);//抽象方法
6.         abstract public int MyInt { get; set; }//抽象属性
7.         public int PerimeterLength()//普通的非抽象方法
8.         {
9.             return TriangleSideCount * SideLength;
10.         }
11.     }
12.     class MyClass1 : Mybase
13.     {
14.         public override void PrintStuff(string s)
15.         {
16.             Console.WriteLine(s);
17.         }
18.         private int myint;
19.         public override int MyInt
20.         {
21.             get
22.             {
23.                 return myint;
24.             }
25.             set
26.             {
27.                 myint = value;
28.             }
29.         }
30.     }
31.  
32. //调用
33. //7、抽象成员
34.             //必须加abstract 可以在方法 属性 事件 索引共4个类型的成员前面加
35.             //其只可以在抽象类中声明，不能加virtual，实现必须加override。
36.             //抽象类，只能被继承。
37.  
38.             MyClass1 mc1 = new MyClass1();
39.             mc1.PrintStuff("hello world!");
40.             mc1.MyInt = 100;
41.             Console.WriteLine(mc1.MyInt);
42.  
43.             //8、密封类，与抽象类相反，无法用作基类 关键字sealed。无法被继承。跟final 有点像。
44.             //9、静态类
45.             //static 类，其成员必须是静态的。一般为了建立一组不变的数学库或数学方法

1.    sealed class MyData //sealed 修饰符说明此类不能被继承
2.     {
3.        private double d1, d2, d3;
4.        public MyData(double m1, double m2, double m3)
5.        {
6.            d1 = m1;
7.            d2 = m2;
8.            d3 = m3;
9.        }
10.        public double Sum()
11.        {
12.            return d1 + d2 + d3;
13.        }
14.     }
15.    static class ExtendMyData //扩展方法，创建另一个作用于MyData类的实例
16.    {
17.         public static double Average(this MyData md)//关键字和类型。加上this 就可以利用实例调用形式调用方法了
18.        { //而不是用静态调用形式：ExtendMyData.Average(md);
19.            return md.Sum() / 3;
20.        }
21.     }
22.  
23. //调用
24.  //10、扩展方法
25.             MyData md = new MyData(1, 2, 3);
26.             Console.WriteLine(md.Sum());
27.             Console.WriteLine(md.Average());
28.             //11.命名约定
29.             //CardDeck 这种一般用于类，方法，命名空间，属性和公共字段
30.             //totalCycle 这种一般用于局部变量或者形参
31.             //_cycleCount 一般用于事件，私有和受保护的字段

第八章 表达式与运算符

1、比较

浅比较：比较引用 深比较：比较内容。

2、用户定义的类型转换

隐式转换如下：

Public static implicit operator TargetType (SourceType Identifier)

{

Xxxxxx

Return ObjectOftargetType;

}

1. using System;
2. using System.Collections.Generic;
3. using System.Linq;
4. using System.Text;
5.  
6. namespace CsharpStart //运算符重载
7. {
8.     class LimitenInt
9.     {
10.         const int MaxValue = 100;
11.         const int MinValue = 10;
12.  
13.         private int _theValue = 0;
14.         public int TheValue //属性值
15.         {
16.             get
17.             {
18.                 return _theValue;
19.             }
20.             set
21.             {
22.                 if (value < MinValue)
23.                 {
24.                     _theValue = 0;
25.                 }
26.                 else
27.                 {
28.                     _theValue = value > MaxValue ? MaxValue : value;
29.                 }
30.             }
31.         }
32.      // 必需的，public static + 类型 + 关键字 + 运算符 + （操作数）
33.         public static LimitenInt operator -(LimitenInt x)
34.         {
35.             //去一个值的负数为0
36.             LimitenInt li = new LimitenInt();
37.             li.TheValue = 0;
38.             return li;
39.         }
40.  
41.         public static LimitenInt operator -(LimitenInt x, LimitenInt y)
42.         {
43.             LimitenInt li = new LimitenInt();
44.             li.TheValue = x.TheValue - y.TheValue;
45.             return li;
46.         }
47.  
48.         public static LimitenInt operator +(LimitenInt x, LimitenInt y)
49.         {
50.             LimitenInt li = new LimitenInt();
51.             li.TheValue = x.TheValue + y.TheValue;
52.             return li;
53.         }
54.     }
55. }
56.  
57. //调用
58.             //1、表达式 2、字面值
59.             //234L 长整型 U 无符号整型 UL ； F 浮点型。D double。M decimal，字符字面值 ''
60.             //一般的编译器会让相同的字符串字面值共享堆中的同一个内存空间以节约内存
61.  
62.             //3、运算符重载
63.             LimitenInt li1 = new LimitenInt();
64.             LimitenInt li2 = new LimitenInt();
65.             LimitenInt li3 = new LimitenInt();
66.  
67.             li1.TheValue = 10;
68.             li2.TheValue = 96;
69.  
70.             li3 = -li1;
71.             Console.WriteLine("-{0}={1}", li1.TheValue, li3.TheValue);
72.  
73.             li3 = li1 + li2;//属性值本身有范围限定
74.             Console.WriteLine("{0} + {1} = {2}", li1.TheValue, li2.TheValue, li3.TheValue);
75.  
76.             li3 = li1 - li2;
77.             Console.WriteLine("{0} - {1} = {2}", li1.TheValue, li2.TheValue, li3.TheValue);
78.  
79.             //4、typeof 运算符
80.             //返回为Type类型 使用如下： s.GetType().Name;此方法对所有的类型都有效
81.             //打印命名空间所有的字段名与方法名
82.             Type t = typeof(Program);
83.             FieldInfo[] fi = t.GetFields(); // 字段 集
84.             MethodInfo[] mi = t.GetMethods();//方法 集
85.  
86.             foreach (FieldInfo pf in fi)
87.             {
88.                 Console.WriteLine("field:{0}", pf.Name);
89.             }
90.  
91.             foreach (MethodInfo m in mi)
92.             {
93.                 Console.WriteLine("Method:{0}", m.Name);
94.             }

第九章 语句

//switch 语句段中，必须以一个跳转语句结尾，这和C/C++不同。

//跳转语句包括：break;goto;return;continue;throw等。

//using 语句：首先介绍资源，包括分配资源，使用资源，处置资源

第十章 结构

1. //1、结构是值类型，隐式密封，sealed，不能被派生。 但是，声明的时候需要加修饰符。比如public，默认为private。
2. //2、结构的内存排列在栈中。其类型变量不能为null。
3. //3、结构vs类 1）类是引用类型 2）结构是隐式密封，不能被派生
4.  
5. CSimple cs1 = new CSimple(),cs2;//类实例 （在堆中分配了空间）
6. Simple ss1 = new Simple(),ss2 = new Simple();//结构实例 （没有在堆中分配空间）
7. //这里需要注意一个问题，我们也可以不使用new运算符创建结构的实例
8. //但是我们必须显式的设置所有的数据成员之后，才可以使用它们的值和函数成员
9. cs1.x = ss1.x = 3;
10. cs1.y = ss1.y = 5;
11.  
12. cs2 = cs1;//赋值类实例 （赋值之后，两个类的引用指向堆中同一块空间）
13. ss2 = ss1;//赋值结构实例 （赋值之后，两个结构变量值相等。此变量在栈中）
14.  
15. //4、结构可以有实例构造函数（必须有参）和静态构造函数，但不允许有析构函数
16. //5、要想把一个结构实例作为引用类型对象，必须创建装箱操作。

第十一章 枚举

1.     [Flags]
2.     enum CardDeckSetting : uint
3.     {
4.         SingleDeck = 0x01, //位0
5.         LargePictures = 0x02, //位1
6.         FancyNumbers = 0x04, //位2
7.         Animation = 0x08 //位3
8.     }
9.     enum TrafficLight : byte
10.     {
11.         Green = 1,
12.         Yellow = 10,
13.         Red = 30
14.     }
15. #region 枚举类型 定义在class外面，这样可以被其他class调用
16.  
17.     enum Color
18.     {
19.         Red = 1, // 中间用 逗号
20.         Blue = 2,
21.         Green = 3
22.     }
23. #endregion
24.  
25. class MyClass
26.     {
27.         bool UseSingDeck = false,
28.               UseBigPictures = false,
29.               UseFancyNumbers = false,
30.               UseAnimation = false,
31.               UseAnimationAndFancyNumbers = false;
32.         public void SetOptions(CardDeckSetting ops)
33.         {
34.             UseSingDeck = ops.HasFlag(CardDeckSetting.SingleDeck);
35.             UseBigPictures = ops.HasFlag(CardDeckSetting.LargePictures);
36.             UseFancyNumbers = ops.HasFlag(CardDeckSetting.FancyNumbers);
37.             UseAnimation = ops.HasFlag(CardDeckSetting.Animation);
38.            // UseAnimationAndFancyNumbers = ops.HasFlag(CardDeckSetting.Animation | CardDeckSetting.FancyNumbers);
39.             //上句可以改写为
40.             CardDeckSetting testFlags = CardDeckSetting.Animation | CardDeckSetting.FancyNumbers;
41.             UseAnimationAndFancyNumbers = ops.HasFlag(testFlags);
42.         }
43.  
44.         public void PrintOptions()
45.         {
46.             Console.WriteLine("Options Setting :");
47.             Console.WriteLine("Use Single Deck - {0}", UseSingDeck);
48.             Console.WriteLine("Use Big Pictures - {0}", UseBigPictures);
49.             Console.WriteLine("Use Fancy Numbers - {0}", UseFancyNumbers);
50.             Console.WriteLine("Use Animation - {0}", UseAnimation);
51.             Console.WriteLine("Use Animation and FancyNumbers - {0}", UseAnimationAndFancyNumbers);
52.  
53.         }
54.         public int val = 20;
55.         public void ListInts(params int[] inVals)
56.         {
57.             if (inVals != null && inVals.Length != 0)
58.             {
59.                 foreach (int i in inVals)
60.                 {
61.                     //i *= 10;//迭代变量只能输出，无法赋值，赋值用for语句。
62.                     Console.WriteLine("{0}", i);
63.                 }
64.             }
65.         }
66.  
67.         public int Cal(int a, int b, int c)
68.         {
69.             return a * b * c;
70.         }
71.         public int Cal1(int a, int b, int c = 9) //可选参数，填入默认值
72.         {
73.             return a * b * c;
74.         }
75.     }

第十二章 数组

数组的结构，其本身是一个引用类型。

数组是引用类型与C++有很大区别，C#中数组的维度是在实例化后才会被确定的，所以，我们申明的时候，一般都不加数字进去。

类似： int[] aa = new int[4];

矩形数组初始化：

交错数组初始化：

数组是从system.array类当中继承而来，有一些个方法可以应用。

比如下面的Clone方法：

对于克隆值类型与克隆引用类型效果不一样。如下图所示：

比较数组类型

1.  //1、元素 维度 维度的长度 数组长度=维度*维度的长度
2.  //2、数组的类型：矩形数组（类似矩阵） 交错数组（行矩阵长度不等）
3.  //3、数组是对象，是引用类型。引用在堆或者栈上
4.  // 尽管数组是引用类型，但是其元素可以是值类型（栈和堆中）或者是引用类型。（都在堆中）
5.  //4、矩形数组与一维数组
6.  // 注意：不可以在声明数组的时候，把维度的长度加进去，逗号（维度）是类型的一部分，维度的长度不是。
7.  // 方括号在基类后，而不在变量名称后。数组声明后，其维度数就确定了，维度长度在数组实例化后确定。
8.  int[] arr2 = new int[4];//数值型数组
9.  MyClass[] mcArr = new MyClass[4];//引用型数组，没有（）括号。
10.  
11.  int[] myIntArray;//声明数组
12.  myIntArray = new int[4];//实例化数组
13.  for (int i = 0; i < 4; ++i)//赋值并打印
14.  {
15.      myIntArray[i] = i*10;
16.      Console.WriteLine("Value of element {0} = {1}",i,myIntArray[i]);
17.  }
18.  //数组的初始化 , 省略 new int[] 依然可以说明。一般最后一个维度可以认为是元素个数
19.  int[] arrayF = new int[3] { 10, 20, 30 };
20.  int[] arrayS = { 10,20,30};
21.  
22.  int[,] arrayT = new int[2, 3] { { 0, 1, 2 }, { 10, 20, 30 } };
23.  int[,] arrayFO = {{0,1},{2,3}};
24.  //当然，数组也支持初始化一个隐式类型的数组
25.  var arr = new [,] {{0,1},{2,3}};
26.  
27.  //5、交错数组
28.  //简单理解为数组的数组，其子数组的个数可以不同，注，不能在声明语句中初始化顶层数组之外的数组
29. // int[][] jagArr = new int[3][4];//eeor
30.  int[][] jagArr = new int[3][];//这样可以，初始化顶层数组。其本身有四个对象。
31.  //交错数组的初始化不能在一个步骤中完成，其本身是每个数组独立创建完成的。
32.  //步骤：1、 实例化顶层数组 2、分别实例化每一个子数组
33.  jagArr[0] = new int[] { 10, 20 };
34.  jagArr[1] = new int[] { 20, 30 };
35.  jagArr[2] = new int[] { 30, 40 };
36.  
37.  //混合体，交错数组中，可能存在矩形数组。
38.  int[][,] ARR = new int[3][,];//声明并实例化带有3个二维数组的交错数组
39.  ARR[0] = new int[,] {{1,2},{3,4}};
40.  //打印是： ARR.GetLength(0) ARR[i].GetLength(0) ARR[i].GetLength(1) 循环控制的长度
41.  //在foreach 控制语句中，item（迭代变量是只读的）。但对于引用类型数组来说，却不一样
42.  //我们虽然无法改变引用，但我们可以通过迭代变量的属性来改变数据的值。前提是必须是已经存在的对象。
43.  Array[] mcArray = new Array[4];//创建数组
44.  for (int i = 0; i < 4; ++i)
45.  {
46.      mcArray[i] = new Array(); //创建类对象
47.      mcArray[i].MyField = i;//设置字段
48.  }
49.  foreach(Array item in mcArray)
50.  {
51.      item.MyField += 10;
52.  }
53.  foreach(Array item in mcArray)
54.  {
55.      Console.WriteLine("{0}", item.MyField);
56.  }
57.  
58.  //6、数组协变，即使某个对象不是数组的基类型，我们也可以把它赋值给数组元素
59.  //7、C#数组从system.array类继承而来，继承了基类的很多有用的属性和方法
60.  // Rank/Length/GetLength/Clear/Sort/BinarySearch/Clone/IndexOf/Reverse/GetUpperBound
61.  int[] array99 = new int[] { 12, 13, 90, 98, 43, 67 };
62.  //Array.Sort(array99);
63.  //Array.Reverse(array99);
64.  //8、Clone方法
65.  //克隆值类型会产生两个独立的数组
66.  //克隆引用类型会产生指向相同对象的两个数组
67.  //Clone方法返回Object类型的引用，它必须被强制转换成数组类型
68.  int[] IntArray = new int[] { 1,2,3};
69.  int[] IntArray2 = (int[])IntArray.Clone();//强制转换，浅复制，复制元素
70.  IntArray2[0] = 100;//IntArray 的值也随之改变
71.  IntArray2[1] = 200;//这些值都是在堆中
72.  IntArray2[2] = 300;