1、C#中的访问修饰符
- Public:公开的公共的
- Private:私有的，只能在当前类访问
- Protected:受保护的，只能在当前类的内部以及该类的子类中访问
- internal：只能在当前项目中访问，在同一项目中，internal和Public的访问权限是一样的
- protected internal:protected + internal
- 能够修饰类的访问修饰符只有：Public internal；
- 可访问性不一致：子类的访问权限不能高于父类的访问权限，否则会暴露父类的成员。
2、设计模式(23种)
设计这个项目的一种方式。
3、简单工厂设计模式
class Program
{
static void Main(string[] args)
{
Console.WriteLine("请输入你想要的笔记本品牌");
string brand = Console.ReadLine();
GetNoteBook(brand).SayHello();
Console.ReadKey();
}
/// <summary>
/// 简单工厂的核心，根据用户的输入，创建对象给父类
/// </summary>
/// <param name="brand"></param>
/// <returns></returns>
public static NoteBook GetNoteBook(string brand)
{
NoteBook nb = null;
switch (brand)
{
case "Lenvo":
nb = new Lenovo();
break;
case "IBM":
nb = new IBM();
break;
case "Acer":
nb = new Acer();
break;
case "Dell":
nb = new Dell();
break;
default:
break;
}
return nb;
}
}
/// <summary>
/// 笔记本的父类，抽象类实现多态
/// </summary>
public abstract class NoteBook
{
public abstract void SayHello();
}
/// <summary>
/// 继承于父类，重写父类的方法
/// </summary>
public class Lenovo : NoteBook
{
public override void SayHello()
{
Console.WriteLine( "我是联想笔记。");
}
}
/// <summary>
/// 继承于父类，重写父类的方法
/// </summary>
public class Dell : NoteBook
{
public override void SayHello()
{
Console.WriteLine("我是戴尔笔记本");
//throw new NotImplementedException();
}
}
/// <summary>
/// 继承于父类，重写父类的方法
/// </summary>
public class Acer : NoteBook
{
public override void SayHello()
{
Console.WriteLine("我是宏碁笔记本");
//throw new NotImplementedException();
}
}
/// <summary>
/// 继承于父类，重写父类的方法
/// </summary>
public class IBM : NoteBook
{
public override void SayHello()
{
Console.WriteLine("我是IBM笔记本");
//throw new NotImplementedException();
}
}
4、值传递和引用传递
1、值类型在复制的时候，传递的是这个值的本身。
//值传递和引用传递
int n1 = 10;
int n2 = n1;
n2 = 20;
Console.WriteLine(n1);//10
Console.WriteLine(n2);//20
Console.ReadKey();
2、引用类型在复制的时候，传递的是对这个对象的引用。
也就是说，创建P2对象是将P1赋值给P2，其实是将P1在内存栈中指向堆中的地址赋值给P2。此时P1与P2共用同一块堆中内存空间，也就是指向同一个对象，无论是操作P1还是P2，两者的数据都会改变。
Person p1 = new Person();
p1.Name = "张三";
Person p2 = p1;
p2.Name = "李四";
Console.WriteLine(p1.Name);//李四
Console.WriteLine(p2.Name);//李四
5、序列化与反序列化
序列化：将对象转换为二进制
反序列化：将二进制转换为对象
作用是传输数据。
1、将这个类标记为可以被序列化
static void Main(string[] args)
{
//=====================序列化
Person p = new Person();
p.Name = "李四";
p.Age = 50;
using (FileStream fsWrite = new FileStream(@"e:\Users\Lenovo\Desktop\test.txt", FileMode.OpenOrCreate, FileAccess.Write))
{
//开始序列化对象
BinaryFormatter bf = new BinaryFormatter();
bf.Serialize(fsWrite, p);//调用这个方法就实现了序列化后写文件操作
}
Console.WriteLine("序列化OK");
//=============反序列化
Person p1 = new Person();
using (FileStream fsRead = new FileStream(@"e:\Users\Lenovo\Desktop\test.txt", FileMode.OpenOrCreate, FileAccess.Read))
{
BinaryFormatter bf = new BinaryFormatter();
p1 = (Person)bf.Deserialize(fsRead);//调用这个方法就实现了读数据反序列化操作
}
Console.WriteLine(p1.Name);
Console.WriteLine(p1.Age);
Console.Read();
}
//==================类
[Serializable]//标记类可以被序列化
public class Person
{
private int _age;
private string _name;
public int Age { get => _age; set => _age = value; }
public string Name { get => _name; set => _name = value; }
}
5、部分类（partial）
使用partial关键字，表明该类为部分类。也就是说Person类由多个类共同组成，类中的成员都是共通共用的。
一个类分成多个部分写在不同的地方。
同一个类中不能有有重复的方法，但是允许重载，
public partial class Person
{
private int _age;
private string _name;
public int Age { get => _age; set => _age = value; }
public string Name { get => _name; set => _name = value; }
}
public partial class Person
{
public void test()
{
Console.WriteLine(this.Name);
}
}
6、密封类（sealed）
特点：不能被继承，与外界隔绝联系，但是密封类可以继承其他类。
7、重写ToString()方法
未重写
class Program
{
static void Main(string[] args)
{
Person p = new Person();
Console.WriteLine(p.ToString());//打印的是类的命名空间
Console.ReadKey();
}
}
public class Person
{
}
已重写
class Program
{
static void Main(string[] args)
{
Person p = new Person();
Console.WriteLine(p.ToString());//如果没有重写那么打印的是类的命名空间
Console.ReadKey();
}
}
public class Person
{
//此处重写了ToString方法，ToString是Object的虚方法
public override string ToString()
{
return "Hello Word";
}
}
8、接口（interface）
实现多态的第三种方法。
接口是一种规范、能力。
1、接口中的成员不允许添加访问修饰符，默认就是public
2、接口中没有方法体，不能写方法体。方法体需要写在类中进行实现
3、接口中不能写字段
4、接口中可以写属性
接口是—种规范。
只要一个类继承了一个接口，这个类就必须实现这个接口中所有的成员
为了多态。接口不能被实例化。
也就是说,接口不能new(不能创建对象)
接口中的成员不能加“访问修饰符”，接口中的成员访问修饰符为pub1ic,不能修改。
(默认为pub1ic）接口中的成员不能有任何实现（“光说不做”，只是定义了一组未实现的成员)。
接口中只能有方法、属性、索引器、事件，不能有“字段”和构造函数。
接口与接口之间可以继承,并且可以多继承。
接口并不能去继承一个类，而类可以继承接口（接口只能继承于接口，而类既可以继承接口，也可以继承类)实现接口的子类必须实现该接口的全部成员。
一个类可以同时继承一个类并实现多个接口，如果一个子类同时继承了父类A,并实现了接口IA,那么语法上A必须写在IA的前面。
class MyClass:A,IA0,因为类是单继承的。
显示实现接口的目的:解决方法的重名问题
什么时候显示的去实现接口：
当继承的接口中的方法和参数一摸一样的时候,要是用显示的实现接口
当一个抽象类实现接口的时候,需要子类去实现接口。
接口格式:
public interface I..able
{
void test();
}
示例代码：
class Program
{
static void Main(string[] args)
{
IKouLanable Kl = new Student();
Kl.Koulan();// 调用接口中的方法
Student s = new Student();
s.Koulan();//调用类中的方法
Console.ReadKey();
}
}
public class Person
{
public void CHLSS()
{
Console.WriteLine("我是人类，我可以吃喝拉撒睡");
}
}
public class Student : Person, IKouLanable
{
//Student类中的方法
public void Koulan()
{
Console.WriteLine("我也可以扣篮");
}
/// <summary>
/// 显示实现接口
/// </summary>
//接口中的方法
void IKouLanable.Koulan()
{
Console.WriteLine("我也可以扣篮");
}
}
public interface IKouLanable
{
//接口中的成员不允许添加访问修饰符，默认就是public
//接口中没有方法体，不能写方法体。方法体需要写在类中进行实现
void Koulan();
/// <summary>
/// 自动属性
/// </summary>
string Name
{
get;
set;
}
}
9、MD5加密
static void Main(string[] args)
{
string s = GetMD5("123");
Console.WriteLine(s);
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()
string strNew = "";
for (int i = 0; i < MD5Buffer.Length; i++)
{
strNew += MD5Buffer[i].ToString("X2");//X代表16进制 2代表补0位
}
return strNew;
}
ToString(“x2”)为C#中的字符串格式控制符：
X———-十六进制
2———-每次都是两位数
比如0X0A，若没有2，就只会输出0xA
假设有两个数10和26，正常情况十六进制显示0xA、0x1A，这样看起来不整齐，为了好看，可以指定”X2″，这样显示出来就是：0x0A、0x1A。