C#学习八（访问修饰符、简单工厂模式、值类型和引用类型、序列化和反序列化和一些零散的内容）

一、C#中的访问修饰符

public:公开的公共的
private：私有的，只能在当前类的内部访问
protected：受保护的，只能在当前类的内部以及该类的子类中访问
internal：只能在当前项目中访问。在同一个项目中，internal和public的权限是一样的。
protected internal：protected+internal；
1）、能够修饰类的访问修饰符只有两个：public、internal
2）、可访问性不一致。
子类的访问权限不能高于父类的访问权限,会暴露父类的成员

二、简单工程模式

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

namespace _088简单工厂设计模式
{
    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();//抽象类 abstract
    }

    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笔记本");
        }
    }
}

三、值类型和引用类型

值类型；int 、double、char、decimal、bool、enum、struct
引用类型：string、数组、自定义类、集合、object、接口

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

namespace _089_值传递和引用传递
{
    class Program
    {
        static void Main(string[] args)
        {
            //Person p1 = new Person();
            //p1.Name = "张三";
            //Person p2 = p1;
            //p2.Name = "李四";
            //p1.Name = "abc";
            //Console.WriteLine(p1.Name);
            //Console.WriteLine(p2.Name);

            //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);

            int number = 10;
            TestTwo(ref number);
            Console.WriteLine(number);
            Console.ReadKey();
        }  

        public static void TestTwo(ref int n)
        {
            n += 10;
        }

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

四、序列化和反序列化

序列化：就是将对象转化为二进制
反序列化：就是将二进制转化为对象
作用：传输数据。

序列化：
1）、将这个类标记为可以被序列化的【Serializable】

using System.IO;
using System.Runtime.Serialization.Formatters.Binary;

namespace _090u序列化和反序列化
{
    class Program
    {
        static void Main(string[] args)
        {
            //Person p = new Person();
            //p.Name = "张三";
            //p.Gender = '男';
            //p.Age = 30;
            //using (FileStream fsWrite = new FileStream(@"C:\Users\叶靖\Desktop\1.txt", FileMode.OpenOrCreate, FileAccess.Write))
            //{
            //    //开始序列化对象
            //    BinaryFormatter bf = new BinaryFormatter();
            //    bf.Serialize(fsWrite, p);
            //}
            //Console.WriteLine("序列化成功");

            //接受对方发送来的二进制，反序列化成对象
            Person p; 
            using(FileStream fsRead = new FileStream(@"C:\Users\叶靖\Desktop\1.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);
        }
    }


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

partial部分类

namespace _091_部分类
{
    class Program
    {
        static void Main(string[] args)
        {

        }
    }

    public partial class Person
    {
        private string _name;

        public void Test()
        {

        }

    }

    public partial class Person
    {
        public void Teat(string Name)
        {

        }
    }
}

密封类
不能够被其它类继承，但能继承其他类

namespace _092_密封类
{
    class Program
    {
        static void Main(string[] args)
        {

        }
    }

    public  sealed class Person :Tests
    {

    }

    public class Tests
    {

    }
}

重写ToString
给对象使用ToString，打印的对象的命名空间

namespace _093_重写父类的Tostring
{
    class Program
    {
        static void Main(string[] args)
        {
            Person p  = new Person();   
            Console.WriteLine(p.ToString());
            Console.ReadKey();
        }
    }

    public class Person//子类可以重写父类的方法
    {
        public override string ToString()//虚方法
        {
            return "Hello World";
        }
    }
}

MD5加密

using System.Security.Cryptography;
using System.Text;

namespace _098MD5加密
{
    class Program
    {
        static void Main(string[] args)
        {
            //woaini  woaini
            //202cb962ac59075b964b07152d234b70
            // string s = GetMD5("123");
            //202cb962ac59075b964b07152d234b70
            //202cb962ac59075b964b07152d234b70
            //202cb962ac5975b964b7152d234b70
            //3244185981728979115075721453575112
            //Console.WriteLine(s);
            //Console.ReadKey();
            //double n = 123.456;
            //Console.WriteLine(n.ToString("C"));
            //Console.ReadKey();
        }

        public static string GetMD5(string str)
        {
            //创建MD5对象
            MD5 md5 = MD5.Create();
            //开始加密
            //需要将字符处转换成字节数组
            byte[] buffer = Encoding.GetEncoding("GBK").GetBytes(str);
            //返回一个加密好的字节数组
            byte[] MD5Buffer = md5.ComputeHash(buffer);

            //将字节数组转换成字符串
            //字节数组---字符串
            //将字节数组中每个元素按照指定的编码格式解析成字符串
            //直接将数组ToString();
            //将字节数组中的每个元素ToString()
            //  return Encoding.GetEncoding("GBK").GetString(MD5Buffer);

            // 189 273 345 我爱你
            // 189 273 345
            string strNew = "";
            for (int i = 0; i < MD5Buffer.Length; i++)
            {
                strNew += MD5Buffer[i].ToString("x2");//x是转化为16进制，2是让当显示10为OXA时显示为0X0A
            }
            return strNew;
        }
    }
}