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.多态实现计算器

 (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;

                   }

            }

 (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)抽象方法，抽象类就是为了被子类继承，重写的

   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 

   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. 面向对象计算器(简单工厂计算器)

(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;

                   }

            }