接口，抽象类，继承，多态，重写

1.抽象类

public abstract class AbstractPhone
{
public int Id { get; set; }
public string Name { get; set; }
/// <summary>
/// 子类有，但是内容各不相同的定义为抽次属性，只能在抽象类中使用
///也可以用virtual实现，子类重写该方法（但是父类如果用virtual实现的话，必须定义为方法，
///有实现，但是在当前类中没有意义类中）
/// </summary>
public abstract void System();
public virtual void Text()
{
Console.WriteLine("basePhone");
}
}

2.接口

/// <summary>
/// 接口：就是一个约束
/// 接口中只能包含：属性，没有方法体的方法，事件，索引器
/// </summary>
public interface IExtend
{

//string Remark;//字段不能有，报错
//delegate void DoWork();//委托不行，会报错
//构造函数不行
//class Test { }//类种类不行
void Phone();//接口默认是public的，不允许修饰，不能有方法体
string Remark { get; set; }//属性可以有
event Action OpenDoorHandler;//事件可以
int this[int index] { get; set; }//索引器可以
}

3.继承

public class Iphone:AbstractPhone,IExtend
{
public override void System()
{
Console.WriteLine("IOS");
}
public void Phone()
{
Console.WriteLine("Iphone phote");
}
}

 

public class P10: AbstractPhone, IExtend
{

public event Action OpenDoorHandler;

public override void System()
{
Console.WriteLine("Andriod");

}
public void Phone()
{
Console.WriteLine("Iphone phote");
}
}

IPhone和P10都继承AbstractPhone，但是抽象方法System的实现逻辑不同，这就是多态，实现抽象方法需要重写父类的方法

4.面向抽象

public class Student
{
/// <summary>
/// 面向抽象：
/// 1. 一个方法可以满足多个类型的诉求
/// 2. 支持扩展，对扩展开放，对修改关闭，增加任何一个手机类型，都不用修改此方法都可以用
/// </summary>
public void Play(AbstractPhone phone)
{
Console.WriteLine(phone.Id + "" + phone.Name);
}
/// <summary>
/// 与上面的Play方法相同
/// </summary>
public void Play<T>(T phone) where T : AbstractPhone
{
Console.WriteLine(phone.Id + "" + phone.Name);
}
}

5.

class Program
{
/// <summary>
/// 抽象类：代码重用+约束
/// 抽象方法：约束，就是继承的子类必须有这个方法，但是怎么实现由自己定
/// 封装，继承，多态，重写
/// 什么情况下用抽象类？什么情况下用接口？
/// 接口抽象类：面向抽象编程，可以做到开闭原则（对扩展开放，对修改关闭），搭建框架时，追求扩展性的时候，就会用上

// 抽象类：代码重用+约束 单继承 类 ->(因为是类，所以不能跨产品)

/// 接口：约束 多继承 相当于扩展方法类 ->可以跨产品
/// 大多数情况下用接口，有代码重用的情况下用抽象类

/// </summary>
/// <param name="args"></param>
static void Main(string[] args)
{
AbstractPhone ap = new Iphone();//抽象类中有未实现的方法，所以不能直接实例化，可以用子类来实例化。
//ap只能调用抽象类约束的方法，ap在运行时是由Phone()方法的，但是编译时报错，
//是因为在编译的时候，编译器会根据变量的类型决定该类型有没有该方法，
//可以绕开编译器调用,用dynamic可以避开编译器
dynamic dphone = ap;
dphone.Phone();
ap.System();//ios
AbstractPhone P = new P10();//抽象类中有未实现的方法，所以不能直接实例化，可以用子类来实例化。
P.System();//adriod
IExtend t = new Iphone();//t只能调用接口约束的方法
t.Phone();//只能调用实现的接口方法
IExtend t1 = new P10();
t1.Phone();
//面向抽象
Student s = new Student();
Iphone iphone = new Iphone();
P10 p10 = new P10();
s.Play(iphone);
s.Play(p10);
Console.ReadLine();//多态：子类继承父类，重写父类的方法，就是多态（重写逻辑各不相同）

}

标签：Console,重写,void,多态,抽象类,方法,public,AbstractPhone
来源： https://www.cnblogs.com/fblogs/p/12104978.html