C#-笔记-多态-第四章

多态

概念：让一个对象能够表现出多种状态（类型）
虚方法
关键字virtual override
步骤：将父类的方法标记为虚方法，使用关键字virtual，这个函数可以被子类重新写一个遍历。

public class RealDuck {
            public virtual void sayHell() {
                Console.WriteLine("嘎嘎亂叫");
            }
        }
        public class XpDuck: RealDuck
        {
            public override void sayHell()
            {
                Console.WriteLine("吱吱亂叫");
            }
        }
        public class MtDuck: RealDuck
        {
            public override void sayHell()
            {
                Console.WriteLine("嘎嘎亂叫");
            }
        }

调用：

            RealDuck rd = new RealDuck();
            XpDuck xd = new XpDuck();
            MtDuck md = new MtDuck();
            //声明父类类型的数组
            RealDuck[] ducks = {rd,xd,md};
            for (int i = 0; i < ducks.Length; i++)
            {
                ducks[i].sayHell();
            }
            Console.ReadKey();
        }

抽象类：
当父类的方法不知道如何去实现的时候，可以考虑将父类写成抽象类，将方法写成抽象方法。关键字abstract
1.抽象成员必须标记为abstract，并不能有任何实现。
2.抽象成员必须在抽象类中
3.抽象类不能被实例化
4.子类继承抽象类后，必须把父类中的所有抽象成员都重写。（除非子类也是一个抽象类，则可以不重写）
5.抽象成员的访问修饰符不能是private
6.在抽象类中可以包含实例成员，并且抽象类的实例成员可以不被子类实现
7.抽象类是有构造函数的，虽然不能被实例化
8.如果父类的抽象方法中有参数，那么继承这个抽象父类中的子类在重写父类的方法的时候必须传入对应的参数
如果抽象父类的抽象方法中有返回值，那么子类在重写这个抽象方法的时候，也必须要传入返回值。
如果父类的方法有默认的实现，并且父类需要被实例化，这是可以考虑将父类定义成一个普通类，用虚方法实现。
如果父类中的方法没有默认实现，父类也不需要被实例化，则可以将该类定义为抽象类。
调用：

Animal a = new Dog();
a.Bark();
Animal b = new Cat();
b.Bark();

public abstract class Animal {
            //抽象方法（因为他没意义不能写只能用抽象类写）
            //唯一的意义就是让子类重写
            public abstract void Bark();
            //public void Test() {
            //    //空实现
            //}
        }
        public class Dog : Animal
        {
            public override void Bark()
            {
                Console.WriteLine("小狗汪汪叫");
            }
        }
        public class Cat : Animal {
            public override void Bark()
            {
                Console.WriteLine("小貓喵喵叫");
            }
        }

设计模式

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

简单工厂设计模式。

class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("輸入你想要的筆記本品牌");
            string brand = Console.ReadLine();
            NoteBook nb = GetNoteBook(brand);
            nb.Say();
            Console.ReadKey();
        }
        /// <summary>
        /// 简单工厂的核心  根据用户的输入创建对象赋值给父类
        /// </summary>
        /// <param name="brand">传入用户输入的</param>
        /// <returns>nb</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;
        }
        /// <summary>
        /// 父类用虚方法  子类重写父类的方法
        /// </summary>
        public abstract class NoteBook
        {
            public abstract void Say();
        }
        public class Lenovo : NoteBook
        {
            public override void Say()
            {
                Console.WriteLine("我是聯想筆記本");
            }
        }
        public class Acer : NoteBook
        {
            public override void Say()
            {
                Console.WriteLine("我是弘基筆記本");
            }
        }
        public class IBM : NoteBook
        {
            public override void Say()
            {
                Console.WriteLine("我是IBM筆記本");
            }
        }
        public class Dell : NoteBook
        {
            public override void Say()
            {
                Console.WriteLine("我是戴爾筆記本");
            }
        }

    }

值传递和引用传递

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

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

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

作用：传输数据
只有被Serializable标记的类创建出的类才能被序列化。

Person p = new Person();
            p.Name = "李四";
            p.Age = 21;
            p.Gender = '男';
            using (FileStream fsWrite = new FileStream(@"C:\Users\H0772690\Desktop\new.txt",FileMode.OpenOrCreate,FileAccess.Write))
            {
                //开始序列化对象
                BinaryFormatter bf = new BinaryFormatter();
                bf.Serialize(fsWrite, p);
            }
            Console.WriteLine("ok");
        [Serializable]
        public class Person
        {
            private string _name;
            private char _Gender;
            private int _age;
            public string Name { get => _name; set => _name = value; }
            public char Gender { get => _Gender; set => _Gender = value; }
            public int Age { get => _age; set => _age = value; }
        }

反序列化
//接受对方发过来的二进制 反序列化

 Person p;
            using (FileStream fsRead=new FileStream(@"C:\Users\H0772690\Desktop\new.txt", FileMode.OpenOrCreate, FileAccess.Read))
            {
                BinaryFormatter bf = new BinaryFormatter();
                p = (Person) bf.Deserialize(fsRead);
            }
            Console.WriteLine(p.Age);
            Console.WriteLine(p.Name);
            Console.WriteLine(p.Gender);
            Console.ReadKey();
[Serializable]
        public class Person
        {

            private string _name;
            private char _Gender;
            private int _age;
            public string Name { get => _name; set => _name = value; }
            public char Gender { get => _Gender; set => _Gender = value; }
            public int Age { get => _age; set => _age = value; }
        }

partial其他类：
类不能重名（重载不算），但是还是有一个方法，两个相同类名加一个partial
Partial表示类的一部分，写多个都可以

public partial class Person
        {
        }

Sealed关键字，密封类 不能被继承 但是可以继承别人
public sealed class Student {

        }

重写父类的ToString（）方法