前言： 完全是我在学习过程中记录的笔记，只不过分享一下让很多刚开始学习.net编程的人能够很快的学会C#语言
- 多态的一些说明
(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) 新建一个控制台应用程序，起名为：简单工厂计算器(最好写成英文的，我是为了学习直接写成中文的了)
(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;
}
}