接口-抽象，虚方法

1.父类对象需要实例化有意义就用虚方法实现多态，父类中只有抽象方法，就定义抽象类，接口也如此，规范一注

标准的方法接口

设计模式就是对对一套常用的设计规划总结，对程序中出现的问题写了解决方案，用子类返回给抽象父类

<span style="font-size:18px;"> class Program
{
static void Main(string[] args)
{
Console.WriteLine("请输入您想要的笔记本品牌");
string brand = Console.ReadLine();
NoteBook nb = GetNoteBook(brand);
nb.SayHello();
Console.ReadKey();
}

/// <summary>
/// 简单工厂的核心 根据用户的输入创建对象赋值给父类
/// </summary>
/// <param name="brand"></param>
/// <returns></returns>
public static NoteBook GetNoteBook(string brand)
{
NoteBook nb = null;
switch (brand)
{
case "Lenovo": nb = new Lenovo();
break;
case "IBM": nb = new IBM();
break;
case "Acer": nb = new Acer();
break;
case "Dell": nb = new Dell();
break;
}
return nb;
}
}

public abstract class NoteBook
{
public abstract void SayHello();
}

public class Lenovo : NoteBook
{
public override void SayHello()
{
Console.WriteLine("我是联想笔记本，你联想也别想");
}
}

public class Acer : NoteBook
{
public override void SayHello()
{
Console.WriteLine("我是鸿基笔记本");
}
}

public class Dell : NoteBook
{
public override void SayHello()
{
Console.WriteLine("我是戴尔笔记本");
}
}

public class IBM : NoteBook
{
public override void SayHello()
{
Console.WriteLine("我是IBM笔记本");
}
}</span>

3序列化和反序列化方法 BinaryFormatter

static void Main(string[] args)
{
//要将p这个对象 传输给对方电脑
Person p = new Person();
p.Name = "张三";
p.Age = 19;
p.Gender = '男';
using (FileStream fsWrite = new FileStream(@"C:\Users\SpringRain\Desktop\111.txt", FileMode.OpenOrCreate, FileAccess.Write))
{
//开始序列化对象
BinaryFormatter bf = new BinaryFormatter();
bf.Serialize(fsWrite, p);
}
Console.WriteLine("序列化成功");
Console.ReadKey();

//接收对方发送过来的二进制 反序列化成对象
Person p;
using (FileStream fsRead = new FileStream(@"C:\Users\SpringRain\Desktop\111.txt", FileMode.OpenOrCreate, FileAccess.Read))
{
BinaryFormatter bf = new BinaryFormatter();
p = (Person)bf.Deserialize(fsRead);
}
Console.WriteLine(p.Name);
Console.WriteLine(p.Age);
Console.WriteLine(p.Gender);
Console.ReadKey();
}
}

[Serializable]
public class Person
{
private string _name;

public string Name
{
get { return _name; }
set { _name = value; }
}

private char _gender;

public char Gender
{
get { return _gender; }
set { _gender = value; }
}

private int _age;

public int Age
{
get { return _age; }
set { _age = value; }
}
}
}

密封类不能被继承，关键字sealed

接口是一种规范。

只要一个类继承了一个接口，这个类就必须实现这个接口中所有的成员

为了多态。

接口不能被实例化。

也就是说，接口不能new(不能创建对象)

接口中的成员不能加“访问修饰符”，接口中的成员访问修饰符为public,不能修改。

（默认为public）

接口中的成员不能有任何实现（“光说不做”，只是定义了一组未实现的成员）。

接口中只能有方法、属性、索引器、事件，不能有“字段”和构造函数。

接口与接口之间可以继承，并且可以多继承。接口中只能有方法

接口并不能去继承一个类，而类可以继承接口 （接口只能继承于接口，而类既可以继承接口，也可以继承类）

实现接口的子类必须实现该接口的全部成员。

一个类可以同时继承一个类并实现多个接口，如果一个子类同时继承了父类A，并实现了接口IA,那么语法上A必须写在IA的前面。

class MyClass:A,IA{}，因为类是单继承的。显示实现接口的目的：解决方法的重名问题

什么时候显示的去实现接口：

当继承的借口中的方法和参数一摸一样的时候，要是用显示的实现接口，当一个抽象类实现接口的时候，需要子类去实现接口。

面向接口编程，接口使用例子

class Program
{
static void Main(string[] args)
{
//麻雀会飞  鹦鹉会飞  鸵鸟不会飞 企鹅不会飞  直升飞机会飞
//用多态来实现
//需方法、抽象类、接口

IFlyable fly = new Plane();//new MaQue();//new YingWu();
fly.Fly();
Console.ReadKey();

}
}

public class Bird
{
public double Wings
{
get;
set;
}
public void EatAndDrink()
{
Console.WriteLine("我会吃喝");
}
}

public class MaQue : Bird,IFlyable
{

public void Fly()
{
Console.WriteLine("麻雀会飞");
}
}

public class YingWu : Bird, IFlyable,ISpeak
{

public void Fly()
{
Console.WriteLine("鹦鹉会飞");
}

public void Speak()
{
Console.WriteLine("鹦鹉可以学习人类说话");
}
}

public class TuoBird : Bird
{

}

public class QQ : Bird
{

}

public class Plane : IFlyable
{
public void Fly()
{
Console.WriteLine("直升飞机转动螺旋桨飞行");
}
}

public interface IFlyable
{
void Fly();

}

public interface ISpeak
{
void Speak();
}

4、显示实现接口就是为了解决方法重名的问题

class Program
{
static void Main(string[] args)
{
//显示实现接口就是为了解决方法的重名问题
IFlyable fly = new Bird();
fly.Fly();
Bird bird = new Bird();
bird.Fly();

Console.ReadKey();
}
}

public class Bird : IFlyable
{
public void Fly()
{
Console.WriteLine("鸟飞会");
}
/// <summary>
/// 显示实现接口
/// </summary>
void IFlyable.Fly()
{
Console.WriteLine("我是接口的飞");
}

}
public interface IFlyable
{
void Fly();
}

5.

什么时候用虚方法来实现多态?
什么使用用抽象类来实现多态?
什么时候用接口来实现多态?
在这几个类抽象出来的父类必须有方法实现，不需实例化父类用抽象类，如果父类实例化用虚方法，接口
是针对子类有一组共同的行为使用接口