C#基础系列第五篇

前言： 完全是我在学习过程中记录的笔记，只不过分享一下让很多刚开始学习.net编程的人能够很快的学会C#语言

1. 多态的一些说明

 (1) 多态就是为了程序的可扩展性

 (2)多态的使用：将不同的对象当作父类来看，屏蔽掉各个对象间的不同，写出通用代码，做出通用编程，同样调用不同结果，以适应需求的不断变化

 (3)ToString方法有Object提供，使得所有的类型均可以使用Console.WriteLine()方法

            class Person

            {

                   public string Name { get; set; }

                   public int Age { get; set; }

                   //当写第三个的时候写入下面的方法

                   public override string ToString()

                   {

                          return Name;

                   }

            }

            class Program

            {

                   static void Main(string[] args)

                   {

                          int[] nums = { 1, 34, 4, 65, 7, 87, 454 };

                          Console.WriteLine(nums);

                          //输出:System.Int32[]

                          //准备对象

                          Person p = new Person();

                          p.Name = "韩迎龙";

                          p.Age = 19;

                          Console.WriteLine(p);

                          //输出:智能机器.Person

                          //第三个

                          Person p1 = new Person();

                          p1.Name = "韩迎龙";

                          p1.Age = 19;

                          Console.WriteLine(p);

                          //输出张三

                          Console.ReadKey();

                   }

            }

 (4)多态的保障

            1)继承，相同名字的方法(重载不算)

            2)里氏转换原则

 (5)is和as

            1)判断父类继承

            2)判断接口实现

            3)判断拆箱和装箱

　　2.多态实现计算器

+ View Code?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260

(1) 新建一个控制台应用程序，起名为多态计算器    (2)添加一个CalculstingWay类，表示计算的方法               /// <summary>               /// 计算机的计算               /// </summary>               class CalculstingWay               {                      int num1;                      int num2;                      public int Num1                      {                             get { return num1; }                             set { num1 = value; }                      }                      public int Num2                      {                             get { return num2; }                             set { num2 = value; }                      }                      public CalculstingWay(int n1, int n2)                      {                             num1 = n1;                             num2 = n2;                      }                      public virtual int Calculating()                      {                             //这个方法是需要子类重写的                             return 0;                      }               }   (3)添加一个Add类，表示实现加法的计算            /// <summary>               /// 提供加法计算的方法               /// </summary>               class Add:CalculstingWay               {                      public Add(int n1, int n2)                             : base(n1, n2)                      {                      }                      public override int Calculating()                      {                             return base.Num1 + base.Num2;                      }               }           (4)添加一个Sub类，表示实现减法的计算            /// <summary>               /// 提供减法计算的方法               /// </summary>               class Sub : CalculstingWay               {                      public Sub(int n1, int n2)                             : base(n1, n2)                      {                      }                      public override int Calculating()                      {                             return base.Num1 - base.Num2;                      }               }      (5)添加一个Multi类，表示实现乘法的计算            /// <summary>               /// 提供乘法计算的方法               /// </summary>               class Multi : CalculstingWay               {                      public Multi(int n1, int n2)                             : base(n1, n2)                      {                      }                      public override int Calculating()                      {                             return base.Num1 + base.Num2;                      }               }      (6)添加一个Div类，表示实现除法的计算            /// <summary>               /// 提供除法计算的方法               /// </summary>               class Div : CalculstingWay               {                      public Div(int n1, int n2)                             : base(n1, n2)                      {                      }                      public override int Calculating()                      {                             return base.Num1 + base.Num2;                      }               } <br> (7)添加一个Calculator类，表示计算器类               /// <summary>               /// 表示计算器               /// </summary>               class Calculator               {                      //可以进行计算的对象                      CalculstingWay cal;                      public Calculator(int num1, int num2, string oper)                      {                             switch (oper)                             {                                    case "+":                                           cal = new Add(num1, num2);                                           break;                                    case "-":                                           cal = new Sub(num1, num2);                                           break;                                    case "*":                                           cal = new Multi(num1, num2);                                           break;                                    case "/":                                           cal = new Div(num1, num2);                                           break;                                    default:                                           cal = null;                                           break;                             }                      }                      public int jisuan()                      {                             if (cal != null)                             {                                    return cal.Calculating();                             }                             else                             {                                    return -1;                             }                      }               }

　　3. 抽象方法

 (1) 父类提供一个可以被重写的方法，有子类重写，通过父类，new子类来调用

 (2)父类不需要方法体

 (3)语法：[public] abstract 返回类型 方法名(参数);

                   和方法相比有以下几点需要注意的：

                   1)去掉方法体，直接在圆括号结束的时候加分号

                   2)加上abstract进行修饰

 (4)抽象方法只允许在抽象类中存在

            1)只要在class关键字前面用abstract修饰即可

                   abstract class 类名

                   {

                          //成员

                   }

(5)抽象方法，抽象类就是为了被子类继承，重写的

+ View Code?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65

abstract class Animal            {                   public abstract void Shout();            }            class Dog : Animal            {                   public override void Shout()                   {                          Console.WriteLine("财旺福王运道旺");                   }            }            class Cat : Animal            {                   public override void Shout()                   {                          Console.WriteLine("喵喵喵");                   }            }            class Program            {                   static void Main(string[] args)                   {                          Animal[] animals = {                                                                new Dog(),                                                              new Cat()                                                         };                          for (int i = 0; i < animals.Length; i++)                          {                                 animals[i].Shout();                          }                          Console.ReadKey();                   }            }

 (6)抽象方法的细节

            1)抽象类中可以包含什么东西？

                   ->比一般类多了抽象成员

                   ->抽象成员有有什么：方法，属性，索引器，事件声明

            2)抽象类不允许实例化，不能new

            3)抽象类可以有构造方法

            4)抽象类可以来源于非抽象类

                   class MyBase

                   {

                   }

                   abstract class Test : MyBase

                   {

                          public abstract void Func();

                   }

                   class MySub : Test

                   {

                          public override void Func()

                          {

                                 Console.WriteLine("抽象类可以来源于非抽象类");

                          }

                   }

            5)抽象类必须被子类重写，除非子类也是抽象的

 (7)练习：有一个形状Shape类，派生出圆Circle，矩形Rectangle和正方形Square,分别计算他们的面积Area和周长Perimeter 

+ View Code?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171

1)新建一个控制台项目:起名为多态小案例    2)添加一个Shape类，实现计算面积和周长的方法                    abstract class Shape                    {                           public abstract double GetArea();                           public abstract double GetPerimeter();                    }    3)添加一个Circle类，实现计算圆的面积和周长                    class Circle : Shape                    {                           int r;                           public Circle(int r)                           {                                  this.r = r;                           }                           public override double GetArea()                           {                                  return Math.PI * Math.Pow(r, 2);                           }                           public override double GetPerimeter()                           {                                  return 2 * Math.PI * r;                           }                    }   4)添加一个类，实现计算矩形的面积和周长                    class Rectangle : Shape                    {                           double widthX;                           double heightY;                           public Rectangle(double widthX, double heightY)                           {                                  this.widthX = widthX;                                  this.heightY = heightY;                           }                           public override double GetArea()                           {                                  return widthX * heightY;                           }                           public override double GetPerimeter()                           {                                  return 2 * (widthX + heightY);                           }                    }   5)添加一个类，实现计算正方形的面积和周长                    class Square : Shape                    {                           double length;                           public Square(double length)                           {                                  this.length = length;                           }                           public override double GetArea()                           {                                  return Math.Pow(length, 2);                           }                           public override double GetPerimeter()                           {                                  return 4 * length;                           }                    }                    class Square1 : Rectangle                    {                           public Square1(double length)                                  : base(length, length)                           {                           }                    }   6)在Main方法中实现的代码如下：                    class Program                    {                           static void Main(string[] args)                           {                                  Circle circle = new Circle(5);                                  Console.WriteLine(circle.GetArea().ToString("0.00"));                                  Console.WriteLine(circle.GetPerimeter().ToString("0.00"));                                  Rectangle rec = new Rectangle(5, 10);                                  Console.WriteLine(rec.GetArea());                                  Console.WriteLine(rec.GetPerimeter());                                  Square square = new Square(5);                                  Console.WriteLine(square.GetArea());                                  Console.WriteLine(square.GetPerimeter());                                  Square1 sqr = new Square1(5);                                  Console.WriteLine(sqr.GetArea());                                  Console.WriteLine(sqr.GetPerimeter());                           }                    }

 (8)抽象属性

            1)使用abstract修饰

            2)去掉方法体

            3)语法：public abstract 返回类型 属性

                          {

                                 get;

                                 set;

                          }

            4)自动属性必须包含get,set方法

            5)抽象属性可以定义只读，只写，

 (9)由子类实现抽象属性的方法

            1)用override重写属性

            2)添加一个字段，使用属性

1. 面向对象计算器(简单工厂计算器)

+ View Code?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349

(1) 新建一个控制台应用程序，起名为：简单工厂计算器(最好写成英文的，我是为了学习直接写成中文的了)         (2)新建一个CalculatingWay类，实现计算机的父类计算                /// <summary>               /// 计算机的计算               /// </summary>               abstract class CalculstingWay               {                      int num1;                      int num2;                      public int Num1                      {                             get { return num1; }                             set { num1 = value; }                      }                      public int Num2                      {                             get { return num2; }                             set { num2 = value; }                      }                      public CalculstingWay(int n1, int n2)                      {                             num1 = n1;                             num2 = n2;                      }                      public abstract int Calculating();               }    (3)新建一个Add类，               /// <summary>               /// 提供加法计算的方法               /// </summary>               class Add:CalculstingWay               {                      public Add(int n1, int n2)                             : base(n1, n2)                      {                      }                      public override int Calculating()                      {                             return base.Num1 + base.Num2;                      }               }    (4)新建一个Sub类，               /// <summary>               /// 提供减法计算的方法               /// </summary>               class Sub : CalculstingWay               {                      public Sub(int n1, int n2)                             : base(n1, n2)                      {                      }                      public override int Calculating()                      {                             return base.Num1 - base.Num2;                      }               }    (5)新建一个Multi类，            /// <summary>               /// 提供乘法计算的方法               /// </summary>               class Multi : CalculstingWay               {                      public Multi(int n1, int n2)                             : base(n1, n2)                      {                      }                      public override int Calculating()                      {                             return base.Num1 + base.Num2;                      }               }       (6)新建一个Div类，            /// <summary>               /// 提供除法计算的方法               /// </summary>               class Div : CalculstingWay               {                      public Div(int n1, int n2)                             : base(n1, n2)                      {                      }                      public override int Calculating()                      {                             return base.Num1 + base.Num2;                      }               }       (7)新建一个Factory类               static class Factory               {                      public static CalculstingWay GetCalculator(int n1,int n2,string oper)                      {                             switch (oper)                             {                                    case "+":                                           return new Add(n1, n2);                                    case "-":                                           return new Sub(n1, n2);                                    case "*":                                           return new Multi(n1, n2);                                    case "/":                                           return new Div(n1, n2);                                    default:                                           return null;                             }                      }               }       (8)在Main方法中写入如下这段代码：               class Program               {                      static void Main(string[] args)                      {                             //提示用户输入                             Console.Write("请用户输入第一个数字：");                             int num1 = GetInputNum();                             Console.Write("请用户输入第一个数字：");                             int num2 = GetInputNum();                             Console.Write("请输入运算符");                             string oper = Console.ReadLine();                             //开始生产                             CalculstingWay cal = Factory.GetCalculator(num1, num2, oper);                             //开始投入使用                             if (cal != null)                             {                                    int res = cal.Calculating();                                    Console.WriteLine("{0}{1}{2}={3}", num1, oper, num2, res);                             }                             else                             {                                    Console.WriteLine("运算符有误");                             }                      }                      public static int GetInputNum()                      {                             return GetInputNum(int.MinValue, int.MaxValue);                      }                      /// <summary>                      /// 完成int类型数据的输入，并返回，要求输入的数字在0到给定的数字之间                      /// </summary>                      /// <param name="max">给定的数字的上限</param>                      /// <returns></returns>                      public static int GetInputNum(int max)                      {                             return GetInputNum(0, max);                      }                      /// <summary>                      /// 完成int数字的输入，要求在给定范围之间                      /// </summary>                      /// <param name="min">给定范围的下线</param>                      /// <param name="max">给定范围的上线</param>                      /// <returns></returns>                      public static int GetInputNum(int min, int max)                      {                             string str = Console.ReadLine();                             int num;                             while (true)                             {                                    try                                    {                                           num = Convert.ToInt32(str);                                           if (num > min && num < max)                                           {                                                  break;                                           }                                           Console.Write("输入数字不再{0}到{1}之间，请重新输入", min, max);                                           str = Console.ReadLine();                                    }                                    catch                                    {                                           Console.Write("输入有误，请重新输入");                                           str = Console.ReadLine();                                    }                             }                             return num;                      }               }