第十四篇——面向对象多态（二）

1、C#中的访问符

public:公共的，级别最高

internal:当前项目内部（程序集）中访问，在同项目中等同于public；。

portect:受保护的访问,只能在当前类和当前类的子类中访问。

当前类中internal 级别高，出了当前类 portect 级别高。

private:私有的

internal protect:

2、简单工厂模式

3、值传递与引用传递

值传递是传递在栈上的值本身

引用传递是传递在堆上的地址

ref:将值传递改变为引用传递

4、序列化与反序列化：传输数据

序列化：将对象转化为二进制

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

序列化与反序列化标记：Serializable表示可序列化的对象

标记： [Serializable]

序列化

            Person per = new Person();
            per.Gender = '男';
            per.Age = 25;
            per.Name = "李四";
            using (FileStream fs = new FileStream(@"233.txt", FileMode.OpenOrCreate, FileAccess.ReadWrite))
            {
                BinaryFormatter bf = new BinaryFormatter();
                bf.Serialize(fs, per);
            }
            Console.WriteLine("序列化成功");

        }

        [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; }
            }
        }

反序列化

            Person per = new Person();
            using(FileStream fs = new FileStream("233.txt",FileMode.OpenOrCreate,FileAccess.Read))
            {
                BinaryFormatter bf = new BinaryFormatter();
                per =(Person)bf.Deserialize(fs);
            }
            Console.WriteLine(per.Name);
            Console.WriteLine(per.Age);
            Console.WriteLine(per.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; }
            }
        }

5、部分类

利用关键字partial 实现同时几个人对同一个类进行编译

不能有重复方法，可以重载（名字可以相同，但参数必须不同）

        public partial class Person
        {

        }
        public partial class Person
        {

        }

6、密封类

利用关键字sealed 达到不可被继承，但可以继承其他类的效果

        public partial class People
        {

        }
        public sealed class Human:People
        {

        }

7、重写父类string

对象.ToString，直接输出对象所在的命名空间，因为所有对象所在类的父类都是object，.ToString是父类object的方法

        static void Main(string[] args)
        {
            Person per = new Person();
            Console.WriteLine(per.ToString());
        }


        public class Person
        {
            public override string ToString()
            {
                return "父类已被重写";
            }

        }

8、接口简介

子类突破单根性，实现对多个父类能级进行多继承的效果

接口就是一个规范、能力

        [public] interface I ... able //声明一个接口  可以有返回值；I开头，able结尾表示XX的能力

           {
            成员;
           }

    public interface IFlyable //声明一个接口，接口中只能有方法
    {
        //不允许添加访问修饰符，默认是public；区别于类，类中不写默认private
        void Person();
        //不允许写带有方法体的函数

        //不允许有字段，字段存储数据，用类存储，不需要用接口
        /// <summary>
        /// 自动属性，编译时自动生成私有字段，且没有方法体，也就没有实现
        /// </summary>
        string Name
        {
            get;
            set;
        }

9、接口特点

1、接口是一种规范。

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

对了实现多态，接口不能被实例化，即接口不能创建对象

2、接口中的成员不能加“访问修饰符”，默认为public，不能修改，接口中的对象不能有任何实现，（只是定义了一组未实现的成员）

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

4、接口与接口之间可以继承，并且可以多继承

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

继承接口的走子类必须实现接口的全部成员

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

5、当一个抽象类是实现接口时需要子类去实现接口

10、显示实现接口

目的是解决方法重名问题

什么时候显示？

当继承的接口中的方法和参数一模一样时，要用显示的是实现接口

            IFlyAble ifa = new Bride();
            ifa.Fly();
            Console.ReadKey();
        }
        //#region
        //        public abstract class Fly
        //        {
        //            public abstract void IfFly();
        //        }
        //        public class MaQue : Fly, IFlyAble
        //        {
        //            public override void IfFly()
        //            {
        //                Console.WriteLine("麻雀会飞");
        //            }
        //        }
        //        public class Niao : Fly
        //        {
        //            public override void IfFly()
        //            {
        //                Console.WriteLine("鸟会飞");
        //            }
        //        }
        //        public class TuoNiao : Fly
        //        {
        //            public override void IfFly()
        //            {
        //                Console.WriteLine("鸵鸟会飞");
        //            }
        //        }
        //        public class QiEr : Fly
        //        {
        //            public override void IfFly()
        //            {
        //                Console.WriteLine("鸵鸟会飞");
        //            }
        //        }
        //        public class ZhiShengJi : Fly
        //        {
        //            public override void IfFly()
        //            {
        //                Console.WriteLine("直升机会飞");
        //            }
        //        }

        //        public interface IFlyAble
        //        {
        //            void IfFly();
        //        }
        //        #endregion
        public class Bride:IFlyAble
        {
            public void Fly()
            {
                Console.WriteLine("鸟会飞");
            }
            void IFlyAble.Fly()
            {
                Console.WriteLine("接口的方法");
            }

        }
        public interface IFlyAble
        {
            void Fly();
        }

11、实现多态的选择

什么时候选择虚方法

给出的几个对象可以抽象出父类，并且至少能写出一个共有的方法，且需要创建父类的对象

比如：几个人的信息，共有的属性都是人类

什么时候选择抽象方法

能抽象出父类但是不知道具体写什么方法实现

比如工厂生产电脑，电脑品牌不同，方法不同，用抽象

什么时候选择接口

找不出父类，但是有共同的能力，写接口

12、超市收银系统