要进入debug文件,除了右键进入资源管理器之外，也可以在解决方案资源管理器右上方，点击显示全部文件按钮，会列出当前项目的文件列表，把要放的文件放入debug即可;
多态的好处 1，减少代码量 2.屏蔽各个子类之间的差异，写出通用的代码;
C#中的访问修饰符;
public 公开的，公共的
private 私有的，只能在当前类的内部访问
protect 受保护的， 只能在当前类的内部以及该类的子类中访问，
internal 只能在当前项目中访问，在同一项目中，internal和public的访问修饰符是一样的，
protected inrernal 它的权限是protected权限加上internal的权限;
修饰类的访问修饰符只有两个，public internal，如果不写类的访问修饰符，默认是internal,表示只有在当前项目中才能访问这个类，出了这个项目就访问不到了，因此我们为了 让在别的项目里也能访问到这个类的话，我们在建类的时候在类的前面加上public
internal的权限和protected相比，在同一个项目中。Internal的权限要比protected大，但是一旦垮了项目，protected的权限要比internal的权限大，因为不同项目之间依然存在继承关系， internal访问不到了，但是由于继承关系，protected成员依然可以跨项目访问，(跨项目的时候1要添加引用，2要添加命名空间);
在命名空间中定义的元素无法显示的声明为private，protected，protected internal;
类中的成员五个访问修饰符都可以定义;
可访问性不一致，子类的访问权限不能高于父类的访问权限;原因是会暴漏父类的成员；
简单工厂设计模式 设计这个项目的一种方式; 有一个牛人把我们写程序当中经常会遇到的问题，没一个问题都写成了一个解决方案;这一个解决方案就是一个设计模式，有23个设计模式；如果把23种设计模式从头到尾敲一遍就是大牛了， 设计模式帮助我们解决在日常开发中遇到的问题，
简单工厂设计模式最核心的就是工厂，这个工厂最后根据用户的输入来返回一个（笔记本对象），但是用户输入的东西是不知道的，只能给他返回一个父类，但是父类里面装的是子类的对象，
重写父类的方法的时候，子类的方法名字和父类被重写方法的名字是一样的，
public abstract class NoteBook
{
public abstract void SayHello();
}
public class Lenovo : NoteBook
{
public override void SayHello()
{
Console.WriteLine("我是联想");
}
}
public class IBM : NoteBook
{
public override void SayHello()
{
Console.WriteLine("我是IBM");
}
}
public class Acer : NoteBook
{
public override void SayHello()
{
Console.WriteLine("我是宏基");
}
}
public class Dell : NoteBook
{
public override void SayHello()
{
Console.WriteLine("我是戴尔");
}
}
public class Test
{
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; //简单工厂最核心的代码部分;
}
}
string brand = Console.ReadLine();
NoteBook nb = GetNoteBook(brand);
nb.SayHello();
值类型：int double char decimal bool enum struct
引用类型：string 数组 自定义类 集合 object 接口
值类型在复制的时候，传递的是这个值的本身，
person p1 = new person();
p1.Name = "张三";
person p2 = p1;
//这行代码表示p1,p2指向同一个对象(p1的new person());现在只要改变p1或者p2的其中任何一个，(p1的new person())其中另外一个值就会变;
//简单的说，p1和p2指向同一块内存，这个时候只要改变p1，那么p2也跟着改变，只改变p2，那么p1也跟着改变; p2.Name = "李四"; //把p2变成了李四，那么p1也成了李四; Console.WriteLine(p1.Name); 输出的是"李四";
引用类型在复制的时候，传递的是对这个对象的引用(地址);
person p = new person();
p.Name = "张三";
Test(p);
Console.WriteLine(p.Name); //p.Name 为李四;
public static void Test(person pp)
{
person p = pp;
p.Name = "李四";
}
不管是形参还是实参都是实实在在在内存中占空间的,
string s1 = "张三";
string s2 = s1;
s2 = "李四";
Console.WriteLine(s1); //张三
虽然是引用类型，但是字符串的不可变性;
Console.WriteLine(s2); //李四
int number = 10;
TestTwo(number);
Console.WriteLine(number); //输出10;
public static void TestTwo(int n)
{
n+=10;
}
int number = 10;
TestTwo( ref number);
Console.WriteLine(number); //输出20;
public static void TestTwo( ref int n)
{
n+=10;
}
ref能够把一个变量，以参数的形式带到一个方法中进行改变，再将改变完成后的值带出方法，
ref的原理是把值类型的值传递变为引用传递，使得两个值类型共占一块内存空间（地址）;
要看变量在栈上的地址，设个断点，运行，然后在即时窗口输入&变量名，按回车;
序列化：就是将对象转换为二进制;
反序列化：就是将二进制转换为对象，
序列化和反序列化的作用：传输数据;
在网络中不管传输什么内容，先把传输的内容二进制，对方接收到的也是二进制，它需要干另外一件事就是反序列化；把这个二进制 反序列化为对象;
public class Person
{
private string _name;
public string Name
{
get{return _name;}
set{_name = value}
}
private int _age;
public int Age;
{
get{return _age;}
set{_age = value}
}
private char _gender;
public char Gender
{
get{return _gender;}
set{_gender = value}
}
}
序列化的第一步 1.将这个类标记为可以被序列化的，在一个类的上面写上[Serializable]指示一个类可以被序列化，此类不可以被继承;
只有被[Serializable]标记的类创建出来的对象 才能被序列化;
person p = new person();
p.Name = "张三";
p.Age = 19;
p.Gender = '男';
using(FileStream fsWrite = new FileStream(@"C:UsershhsDesktop1.txt",FileMode.OpenOrCreate,FileAccess.Write))
{ //开始序列化对象
BinaryFormatter bf = new BinaryFormatter();
bf.Serializa(fsWrite,p);
}
Console.writeline("序列化成功");
//反序列化
Person p;
using(FileStream fsRead = new FileStream(@"C:UsershhsDesktop1.txt",FileMode.OpenOrCreate,FileAccess.Read))
{
BinaryFormatter bf = new BinaryFormatter();
p = (Person)bf.Deserializa(fsRead);
}
Console.WriteLine(p.Name);
Console.WriteLine(p.Age);
Console.WriteLine(p.Gender);
学一个东西一定要知道它是干嘛用的;
在一个命名空间下不允许定义一个重名的类，也不允许在一个类中定义重名的方法（前提是它们没有重载）
我们有的时候必须要在一个命名空间下定义重名的类，比如三个人共同做一个项目，这时候都要写person类，
public partial class Person
{
}
public partial class Person
{
}
//这两个都是person类的一部分，共同组成了person类，这样的话就可以同时对person类进行编程，而且一个部分类的成员在另一个部分类里面全都可以访问; 但是部分类里面不允许有重名的方法（不包括重载）
public sealed class Person //密封类最大的特点就是不能被继承;但是能继承别的类;
{
}
重写toString()方法; 如果直接对象.ToString()，那么打印出来的是它的命名空间;
所有的类都能ToString()，因为所有类都直接或间接继承object类，ToString()是object类的方法;
因为子类不能调用父类的抽象方法，但是子类可以调用父类的虚方法，所以ToString()是虚方法，因为我们可以重写它，子类可以重写父类的虚方法;(当然子类也可以重写父类的抽象方法)
public class Person
{
public override string Tostring()
{
return "Hello World";
}
}
重写了Tostring()方法，但是只是Person类的ToString();其他类的ToString()依旧没变;
接口：
public class Person
{
public void CHLSS()
{
Console.WriteLine("我是人类，我可以吃喝");
}
}
//public class NBAPlayer
//{
// public void KouLan()
// {
// Console.WriteLine("我可以扣篮");
// }
}
public class Student : Person，IKouLanable
{
public void KouLan()
{
Console.WriteLine("我也可以扣篮");
}
}
//由于Student继承了Person类，因此他可以吃喝，但是同时他也想实现可以扣篮，由于继承具有单根性，不能既继承Person，又继承NBAPlayer,这时候我们可以考虑将NBAPlayer定义成一个接口
public interface IKouLanable
//以I开头以able结尾表示一种能力
{
void KouLan();
}
定义成接口之后，Student就可以既继承Person，又可以继承NBAPlayer接口了，
一个类继承了接口，必须要实现这个接口的成员，快速实现Alt+shift+F10
什么时候需要用到接口， 1.类需要实现多继承;因为类是不允许多继承的;
接口就是一个规范，能力;
接口：
[public] interface I...able
{
成员;
}
public interface IFlyable
{
void Fly(); //比抽象方法更省事;
接口中的成员不允许添加访问修饰符;默认就是public，接口中没有方法体，类中成员不添加默认就是private
//抽象类中普通的方法可以有方法体，但是抽象函数不可以，但是在接口中不允许写有方法体的成员;
//接口中不能包含字段;接口不是用来存储数据的，存储数据用类来存，
string Test();
string Name
{
get; //自动属性; 接口中能写方法，但是不能有方法体，属性的本质是get，set方法，因为自动属性没有get，set方法体，因此，接口中可以有自动属性，
set; //get和set本质上也是函数，因此这个自动属性和上面的fly没有区别;
}
}
private string _name;
public string Name
{
get{return _name;}
set{_name = value;}
}
public int Age
{
get;
set;
}
自动属性，虽然我们没有给它写字段，但是在编译的时候会自动的给我们生成一个字段; 自动属性和普通属性的区别，一个有字段，有方法体 ；一个没有字段，没有方法体； 自动属性的缺点，不能在属性里面进行值的限定了，不允许写方法体，那么要对值进行限定就要使用构造函数了;各有各的好处; 自动属性本质上是两个函数，
接口中可以有方法和属性，还可以有索引器(索引器还没学过;)这三个东西本质上都是方法;接口中只能有方法;
接口是一种规范，只要一个类继承了一个接口,这个类就必须实现这个接口中所有的成员;
一个类中，去实现接口中的方法，没有override，有override是重写;
为了多态，接口不能被实例化，也就是说，接口不能new（不能创建对象);
抽象类，静态类，接口不能被实例化;抽象类,接口由于没有对方法进行实现，因此即使创建了对象也没有意义; 因此要实现多态的话，要去指向一个子类对象;
//实现多态的时候，3种方法一般都是父类对象装子类;三种方式都是在继承的基础上实现多态;
IFlyable fly = new Person();
fly.Fly();
public class Person:IFlyable
{
public void Fly()
{
Console.WriteLine("人类在飞");
}
}
public class Bird:IFlyable
{
public void Fly()
{
Console.WriteLine("鸟类在飞");
}
}
public interface IFlyable
{
void Fly();
}
接口中的成员不能加“访问修饰符”，接口中的成员访问修饰符为public，不能修改;
接口中的成员不能有任何实现，这个很我们的抽象类当中的抽象函数是一样的，（都是光说不做，交给子类去做，接口只是定义了一组未实现的成员）;
接口中只能有方法，属性，索引器，事件，这四个本质上都是方法，不能有“字段”和构造函数;不能有字段是因为接口不是用来存储数据的，它表示一种规范，一种能力;
因为接口不能创建对象，因此即使有构造函数没有用
接口与接口之间可以继承，并且可以多继承;类就不能多继承;
public interface M1
{
void Test1();
}
public interface M2
{
void Test2();
}
public interface M3
{
void Test3();
}
public interface SuperInterface:M1,M2,M3
{
}
public class Car : SuperInterface //继承一个大接口，他所继承的接口都要实现;
{
public void Test1();
{
}
public void Test2();
{
}
public void Test3();
{
}
}
接口并不能去继承一个类，而类可以继承接口（接口只能继承接口。而类既可以继承接口，也可以继承类）
实现接口的子类必须实现该接口的全部成员;
一个类可以同时继承一个类并实现多个接口，如果一个子类同时继承了父类A，并实现了接口IA，那么语法上A必须写在IA的前面; class MyClass:A,IA{},因为类是单继承的.
说是说面向对象的编程，但是很多情况下其实就是面向接口的编程;
比如说手机中的天气预报，有很多个APP都有天气；但是这些数据源头是中央气象台； 中央气象台对外提供了一个接口，那么我只要实现这个接口中的成员，按照指定的要求去做，那么就可以得到天气信息；
支付宝之前只有淘宝有，很多网站现在都有，因为也实现了接口，所以现在基本上就是面向接口编程;
麻雀会飞， 鹦鹉会飞 鸵鸟不会飞 企鹅不会飞 直升机会飞
用多态来实现虚方法，抽象类，接口；
IFlyable fly = new YingWu()//new MaQue()//new Plane();
fly.Fly();
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,ISpeakable
{
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 ISpeakable
{
void Speak();
}
//显示实现接口就是为了解决方法的重名问题;
public class Bird:IFlyable
{
public void fly()
{
Console.WriteLine("鸟会飞");
}
void IFlyable.Fly() //显示实现接口; 不允许加访问修饰符，类中的成员默认是private，接口中默认是public
{
Console.WriteLine("我是接口的飞"); //这个其实跟抽象类一样，调用的是父类的函数，只不过在子类中重写了;
}
}
public interface IFlyable
{
void Fly();
}
Bird自己的方法和接口中的方法重名了，
IFlyable fly = new Bird();
fly.Fly(); //接口的飞 本质上访问的是接口的Fly，只不过接口的Fly被子类实现了;接口的Fly是public的
Bird bird = new Bird();
bird.Fly(); //自己的飞
在我提供给你的这几个类当中，如果说你能抽象出一个父类，并且父类当中必须写上这几个子类共有的方法，然后你不知道如何去写这个方法，这个时候要用抽象类
反之，抽象出来的父类可以写，还需要创建这个父类的对象，这个时候用虚方法，
如果这几个类里面根本找不出父类，但是它们都有共同的行为，共同的能力，这个时候拿接口实现多态;
比如鸟和飞机没有父类，但是它们都会飞，这个飞只能写成接口，不能写个父类去继承，因为根本提不出父类，
//真的鸭子会游泳， 木头鸭子不会游泳，橡皮鸭子会游泳; 一看到会干什么，能干什么侧重于能力，能力就由接口来做，把真鸭子作为父类，但是不能在父类里面写游泳函数，因为木鸭子不会，不能写抽象方法，因为真的鸭子需要被创建 对象，真鸭子有意义，虚方法也不合适，因为木鸭子不会游泳，所以用接口最合适;
public class RealDuck:ISwimming
{
public void Swim()
{
Console.WriteLine("真的鸭子靠翅膀游泳");
}
}
public class MuDuck
{
}
public class XPDuck:ISwimming
//不写方法体也不会报错，因为继承于RealDuck了，RealDuck里面有Swim了,但是由于他们游泳的方式不一样，因此没必要继承RealDuck
{
public void Swim()
{
Console.WriteLine("橡皮鸭子漂着游泳");
}
}
public interface Iswimming
{
void Swim();
}
ISwiming swim = new RealDuck()//new XPDuck() ;
swim.Swim();
超市收银管理系统，商品类，仓库类，超市类;
类前面不加访问修饰符，默认是Internal表示同一个项目中可以访问;
第一步，写商品的父类ProductFather;写价格，数量，编号三个自动属性;再写一个父类的构造函数
GUID能够帮助我们产生全世界独一无二的编号，GUID是个结构， Guid.NewGuid().ToString();
第二步，写商品的子类继承父类;写出每个子类的构造函数;
第三部，收银系统中最重要的一个类，仓库类;
存储货物;
List<ProductFather> list1 = new List<ProductFather>(); //这样写表示把所有的商品都堆在一堆了，没有体现出分门别类存储商品;所有货物都混在一起，拿的时候不好拿;
List<List<ProductFather>> list2 = new List<List<ProductFather>>();//在集合里面又放了一个集合;List<ProductFather>这个是数据的类型;
在给list1添加数据的时候，可以把货物对象直接添加进来，坏处是取得时候很麻烦;取得时候不知道哪个下标是谁;看下标对应的是哪个对象;于是乎我们想到用两个集合;
在给list2添加数据的时候只能添加一个集合进去;其实这个集合就是货架;给list2添加进去的不是商品，而是货架;
不管是list1还是list2其实都是整个仓库;
用list1存数据相当于 把商品直接扔进了仓库，在list2中添加进来的是数据的集合，仓库里的货架是货物的集合，所以往仓库添加数据的时候，先添加货架；
List<ProductFather> list1 = new List<ProductFather>();
list1[0] list1[1] list1[2]这些就是货物;//这种不好;
List<List<ProductFather>> list2 = new List<List<ProductFather>>();//这段代码创建出了一个仓库;
list2[0] list2[1] list2[2]这些就是货架;
因为创建仓库的时候已经要有货架了，因此我们要创建仓库类的构造函数;
//list[0]存储宏基笔记本 list[1]存储三星手机 list[2]存储酱油 list[3]存储香蕉
public CangKu()
{
list.Add(new List<ProductFather>());
list.Add(new List<ProductFather>());
list.Add(new List<ProductFather>());
list.Add(new List<ProductFather>());
//如果要1000个对象，就要1000行，但是我们可以通过循环创建;
}
进货：
public void JinPros(string strType,int count)
{
for(int i = 0 ;i < count;i++)
{
switch(strType)
{
case "Acer":
list[0].Add(new Acer(Guid.NewGuid().ToString(),1000,"宏基笔记本"));
break;
case "SangSung":
list[1].Add(new SangSung(Guid.NewGuid().ToString(),2000,"三星手机"));
break;
case "JiangYou":
list[2].Add(new JiangYou(Guid.NewGuid().ToString(),10,"老抽酱油"));
break;
case "Banana":
list[2].Add(new Banana(Guid.NewGuid().ToString()20,"大香蕉"));
break;
}
}
}
//来货之后，我们首先创建仓库对象，然后创建Getpros方法，往里面放货物;
取货：
public ProductFather[] QuPros(string strType,int count)
{
ProductFather[] pros = new ProductFather[conut];
for(int i = 0;i < count; i++)
{
switch(strType)
{
case:"Acer":
pros[i] = list[0][0];
list[0].RemoveAt[0];
break;
case:"SangSung":
pros[i] = list[1][0];
list[1].RemoveAt[0];
break;
case:"JiangYou":
pros[i] = list[2][0];
list[2].RemoveAt[0];
break;
case:"Banana":
pros[i] = list[3][0];
list[3].RemoveAt[0];
break;
}
}
return pros;
}
List<List<ProductFather>> list2 = new List<List<ProductFather>>();//这种存储数据的方式是为了分类;
展示货物,
public void ShowPros()
{
foreach(var item in list)
{
Console.WriteLine(item[0].Name item.count item[0].Price);
}
}
泛型集合嵌套泛型集合的方法，我们以后会经常用到;
List<List<ProductFather>> list = new List<List<ProductFather>>();
list是仓库，我们给它添加的是List<ProductFather>货架;
当创建仓库对象的时候，调用构造函数，我们给它创建货架;
public Cangku()
{
List.Add(new List<ProductFather>());
List.Add(new List<ProductFather>());
List.Add(new List<ProductFather>());
List.Add(new List<ProductFather>());
}
第四步 收银
CangKu ck = new CangKu();//创建仓库对象，会通过仓库的构造函数生成4个货架;但是货架上并没有货物，
public SuperMarket() //创建超市对象的时候，给超市的货架导入货物;
{
ck.JinPros("Acer",1000);
ck.JinPros("SangSung",1000);
ck.JinPros("JiangYou",1000);
ck.JinPros("Banana",1000);
}
跟用户交互的过程
public void AskBuying()
{
string strType = Console.ReadLine();
int count = Convert.Int32(Console.ReadLine());
//去仓库取货
Product[] pros = ck.Qupros(strType,count)
double realMoney = GetMoney(pros);
Console.WriteLine("选择打折方式 1-不打折 2-打九折 3-打八五折 4-买300送50 5-买500送100") //通过简单工厂的设计模式根据用户的输入获得一个打折对象;
CalFather cal = GetCal(input);
double totalMoney = cal.GetTotalMoney(realMoney);
}
public double GetMoney(Product[] pros)
{
double realMoney = 0;
realMoney = pro[0].price * pros.Length; //之所以能这么写，是因为我们知道只有一种商品，如果不同种类，那就不能这么写了，
// for(int i = 0;i < pros.Length;i++)
// {
// realMoney +=pros[i].Price
// }
return realMoney;
}
//由于打折不固定，我们要提取出来一个打折的父类，打折的父类肯定有一个打折的方法，打折的父类不知道子类如何去打折，所以打折的父类只能提供一个抽象的打折方法， 所以要把父类写成一个抽象类，
abstract class CalFather
{
public abstract double GetTotalMoney(double realMoney);
}
class CalNormal:CalFather //正常情况下不打折
{
public override double GetTotalMoney(double realMoney)
{
return realMoney;
}
}
class CalRate:CalFather //按折扣率打折
{
public double Rate
{
get;
set;
}
public CalRate(double rate)
{
this.Rate = rate;
}
public override double GetTotalMoney(double realMoney)
{
return realMoney * this.Rate;
}
}
class CalMN:CalFather
{
public double M
{
get;
set;
}
public double N
{
get;
set;
}
public CalMN(double m,double n)
{
this.M = m;
this.N = n;
}
public override double GetTotalMoney(double realMoney)
{
if(realMoney > this.M)
{
return RealMoney - this.N * (int)(realMoney/this.M);
}
else
{
return realMoney;
}
}
}
简单工厂设计模式,根据用户的输入返回对象; 根据用户的选择打折方式返回一个打折对象;
public CalFather GetCal(string input)
{
CalFather cal = null;
switch(input)
{
case "1":
cal = new CalNormal();
break;
case "2":
cal = new CalRate(0.9);
break;
case "3":
cal = new CalRate(0.85);
break;
case "4":
cal = new CalMN(300,50);
break;
case "5":
cal = new CalMN(500,100);
break;
}
return cal;
}
因为展示货物的方法写在仓库类里面，如果在Main()函数里面只创建仓库对象的话，这个时候仓库只有货架，仓库没有货物，仓库只有在创建超市对象的时候才有货物， 因此在超市类里面写一个方法
public void ShowPros()
{
ck.ShowPros();//因此在Main函数中就不用创建仓库对象了，只要直接调用超市的ShowPros就可以了，
}
static void Main (string args[])
{
//创建超市对象，
SuperMarkrt sm = new SuperMarkrt();
sm.ShowPros();
}
//扩展 现在只能买一样物品，把它改成买可以买多个物品;
将密码输入数据库的时候，我们需要对数据库的密码进行加密，不能在数据库里明文保存;
项目中只要涉及到存用户密码，就要给他MD5加密;
把一个字符串转成MD5值这样一个过程，这就是MD5加密;我们就用代码来做;
把字符串加密成MD5这样一个过程是不可逆的，就是说你只能把字符串变成MD5值，不能把MD5值变成字符串;
简单一点的密码生成的MD5值可以解密过来，但是复杂一点的密码生成的MD5值就不能解密出来;
MD5是一个抽象类，不能创建对象，但是我们可以通过它的Create静态方法模拟一个对象出来;并没有创建对象;
public static string GetMD5(string str)
{
MD5 md5 = MD5.Create(); //创建MD5对象;
//开始加密，将str转换成字符数组;
byte[] buffer = Encoding.Default.GetBytes(str);
//返回一个加密好的字节数组;
byte[] MD5Buffer = md5.ComputerHash(buffer);
//字节数组转字符串，理论上有三种，
//1.将字节数组中每个元素按照指定的编码格式解析成字符串; //pass掉就是我们写的，会产生乱码;
//2.直接将数组ToString();第二种pass因为转的是命名空间
//3.将字节数组中每个元素ToString();
//return Encoding.Default.GetString(MD5Buffer);
string strNew = "";
for(int i = 0 ; i < MD5Buffer.Length;i++)
{
strNew += MD5Buffer[i].ToString("x2");
}
return strNew;
//产生的是10进制的一串数字，但是MD5是16进制的;
}
.ToString("x");//在ToString()参数里面加个"x"就能把10进制转化为16进制;
.ToString("x2");//在ToString()参数里面加个"x2"也能把10进制转化为16进制;x2就是使得16进制更整齐，有些地方的0给补起来了;
.ToString();里面有很多参数，具有转格式的作用;