接口-抽象，虚方法

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.

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