面向对象的编程中,有着一个叫做“依赖倒置原则”
程序设计要依赖与抽象类,而不依赖于具体类
比如说抽象类就相当于是父类“宠物”
具体类就是“狗狗”,狗狗已经具体化了
依赖抽象类,派生出子类的时候就使得程序有更好的扩展性,提高开发效率
有时我们就需要一个容器来保存所有的父类,来统一提高效率
创建一个方法,然后参数是我们的父类Animal(传进去的时候要传父类,否则后面要是把父类传进去,调用的时候子类有的特性父类不一定有)
public static void Display(Animal animal)
{
System.Console.WriteLine(animal.Name);
}
然后调用的时候,dog和cat都是Animal的子类,new两个对象
dog peachas = new dog();
cat egg = new cat();
我们调用方法的时候,就可以把子类的对象传进去
因为子类具有父类的全部功能特性,所以参数可以是子类
Display(peachas);
Display(egg);
上篇文章的is操作符的补充
一二行相当于是右下角的写法的简写
s这个是新建的变量,给他进行了一次显示转换,这个引用的s变量可以立即使用
virtual
标记为virual的函数可以被子类重写,包括方法,索引器,属性,事件
public class Animal
{
public string Name;
public virtual decimal Liability => 0;
}
然后子类要重写父类要用override修饰符
public class Egg : Animal { public long sharesOwbed; }
public class ass : Animal
{
public double mansion;
public override decimal Liability => (decimal)mansion;
}
进行一个向下转换
ass mansion = new ass
{mansion = 2500 };
Animal a = mansion;
Console.WriteLine(mansion.Liability);
Console.WriteLine(a.Liability);
得到两个结果都为2500
class Pet
{
virtual public void Speak()
{ }
}/*比如说我这使用了virtual函数后,使用Pet.Speak()他会自动检测子类有咩有override重写,没有则使用父类的方法
有则使用子类的*/
也可以直接用dog.Speak,直接指向子类,但是我们尽量根据设计原则,依赖于抽象类
直接上一个完全示例
using System;
class Pet
{
virtual public void Speak()
{
Console.WriteLine(Name + "Speaking");
}
public string Name;
public void PrintName()
{
Console.WriteLine("Pet name is " + Name);
}
}
class Dog : Pet
{
public Dog(string name)//在两个子类里分别创建两个构造函数
{
Name = name;
}
new public void PrintName()
{
Console.WriteLine("狗狗的名字是" + Name);
}
override public void Speak()//两个子类都重写父类虚函数
{
Console.WriteLine(Name + "Speaking waw");
}
}
class Cat : Pet
{
public Cat(string name)
{
Name = name;
}
override public void Speak()
{
Console.WriteLine(Name + "Speaking merr");
}
}
class Program
{
static void Main(string[] args)//直接用一个数组来存,用for顺序打印出来,这样遇到需要轮流打印比较多的时候就很便捷
{
Pet[] pets = new Pet[] { new Dog("jack "), new Cat("tom ") };
for (int i = 0; i < pets.Length;++i)
{
pets[i].Speak();
}
}