多态、接口

1、c#中的访问修饰符

public :公开的公共的

private：私有的，只能在当前类的内部访问

protected：受保护的，只能在当前类的内部以及该类的子类中访问。

internal：只能在当前项目中访问。在同一个项目中，internal和public的权限是一样。

protected internal：protected+internal

1)、能够修饰类的访问修饰符只有两个：public、internal。

2)、可访问性不一致。 子类的访问权限不能高于父类的访问权限，会暴漏父类的成员。

2、设计模式 设计这个项目的一种方式。

3、简单工厂设计模式

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _03简单工厂设计模式
{
    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笔记本");
        }
    }
}

4、值类型在复制的时候，传递的是这个值得本身。    引用类型在复制的时候，传递的是对这个对象的引用。   

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _04值类型和引用类型
{
    class Program
    {
        static void Main(string[] args)
        {
            //值类型:int double char decimal bool enum struct 
            //引用类型：string 数组  自定义类 集合 object 接口

            //值传递和引用传递
            //int n1 = 10;
            //int n2 = n1;
            //n2 = 20;
            //Console.WriteLine(n1);
            //Console.WriteLine(n2);
            //Console.ReadKey();

            //Person p1 = new Person();
            //p1.Name = "张三";
            //Person p2 = p1;
            //p2.Name = "李四";
            //Console.WriteLine(p1.Name);
            //Console.ReadKey();

            //Person p = new Person();
            //p.Name = "张三";
            //Test(p);
            //Console.WriteLine(p.Name);
            //Console.ReadKey();

            //string s1 = "张三";
            //string s2 = s1;
            //s2 = "李四";
            //Console.WriteLine(s1);
            //Console.WriteLine(s2);
            //Console.ReadKey();

            int number = 10;
            TestTwo(ref  number);
            Console.WriteLine(number);
            Console.ReadKey();
        }
        //int n=number;
        public static void TestTwo(ref  int n)
        {
            n += 10;
        }

        //Person pp=p;
        public static void Test(Person pp)
        {
            Person p = pp;
            p.Name = "李四";
        }
    }

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

5、序列化：就是将对象转换为二进制   

反序列化：就是将二进制转换为对象   

作用：传输数据。  

序列化：   1)、将这个类标记为可以被序列化的。    

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.IO;
using System.Runtime.Serialization.Formatters.Binary;
namespace _05序列化和反序列化
{
    class Program
    {
        static void Main(string[] args)
        {
            //要将p这个对象 传输给对方电脑
            //Person p = new Person();
            //p.Name = "张三";
            //p.Age = 19;
            //p.Gender = '男';
            //using (FileStream fsWrite = new FileStream(@"C:UsersSpringRainDesktop111.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:UsersSpringRainDesktop111.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; }
        }
    }
}

6、partial部分类

7、sealed密封类 不能够被其他类继承，但是可以继承于其他类。  

8、接口 [public] interface I..able {  成员; }

1）语法特征

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _10接口的语法特征
{
    class Program
    {
        static void Main(string[] args)
        {

        }
    }

    public interface IFlyable
    {
        //接口中的成员不允许添加访问修饰符 ，默认就是public
        void Fly();
        string Test();
        //不允许写具有方法体的函数

     //   string _name;
         string Name
        {
            get;
            set;
        }
    
    }
}

2）自动属性和普通属性

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _11_自动属性和普通属性
{
    class Program
    {
        static void Main(string[] args)
        {
        }
    }
    public class Person
    {
        private string _name;

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

        /// <summary>
        /// 自动属性
        /// </summary>
        public int Age
        {
            get;
            set;
        }
    }
}

3）接口特点

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _12接口特点
{
    class Program
    {
        static void Main(string[] args)
        {
            IFlyable fly = new Bird();//new Person();// new IFlyable();
            fly.Fly();
            Console.ReadKey();
        }
    }
    public class Person:IFlyable
    {
        public void Fly()
        {
            Console.WriteLine("人类在飞");
        }
    }


    public class Student 
    {
        public void Fly()
        {
            Console.WriteLine("人类在飞");
        }
    }

    public class Bird : IFlyable
    {
        public void Fly()
        {
            Console.WriteLine("鸟在飞");
        }
    }

    public interface IFlyable
    {
        //不允许有访问修饰符 默认为public
        //方法、自动属性
        void Fly();
    }



    public interface M1
    {
        void Test1();
    }

    public interface M2
    {
        void Test2();
    }

    public interface M3
    {
        void Test3();
    }


    public interface SupperInterface : M1, M2, M3
    { 
        
    }

    public class Car : SupperInterface
    {

        public void Test1()
        {
            throw new NotImplementedException();
        }

        public void Test2()
        {
            throw new NotImplementedException();
        }

        public void Test3()
        {
            throw new NotImplementedException();
        }
    }

}

4）接口练习

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _13接口练习
{
    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();
    }


}

5）显示实现接口

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _14_显示实现接口
{
    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();
    }
}

6）总结

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _15_总结
{
    class Program
    {
        static void Main(string[] args)
        {
            //什么时候用虚方法来实现多态?
            //什么使用用抽象类来实现多态?
            //什么时候用接口来实现多态?

            //真的鸭子会游泳 木头鸭子不会游泳 橡皮鸭子会游泳

            ISwimming swim = new XPDuck();//new RealDuck();
            swim.Swim();
            Console.ReadKey();
        }
    }

    public class RealDuck:ISwimming
    {

        public void Swim()
        {
            Console.WriteLine("真的鸭子靠翅膀游泳");
        }
    }

    public class MuDuck 
    { 
    
    }

    public class XPDuck : ISwimming
    {

        public void Swim()
        {
            Console.WriteLine("橡皮鸭子飘着游泳");
        }
    }

    public interface ISwimming
    {
        void Swim();
    }
}