面向对象程序设计 [ 日升于东 ]

设计原则

单一职责原则：一个类，只有一个引起它变化的原因
开闭原则：扩展开放，修改封闭
里氏代替原则：子类必须替换掉它们的父类
依赖倒置原则：面向接口编程，而不是面向实现编程
接口隔离原则
合成复用原则：Has-A 和 Is-A
迪米特法则：不要和陌生人说话，最少知识原则

软件系统设计核心

一个项目有多少类：发现类
每个类有什么属性和方法：设计类
每个类之间的关系：设计类

面向对象设计目标

项目可扩展性，可维护性，更方便

软件工作流程

输入（用户界面） -> 运算（业务逻辑） -> 存储（数据库、文件） -> 输出（界面，其他文件）

软件文档

需求说明 -> 概要设计 -> 详细设计

编码过程

变量 -> 语句 -> 属性+方法 -> 类 -> 模块 -> 功能 -> 子系统 -> 软件整体

类、对象

类 -> 对象数据的处理

类 -> 对象的抽象
对象 -> 类的实例化

对象数据

静态特征：属性
动态特征：行为，方法
方法为抽象方法。

public class People{
  //字段私有化，主要作用类内部数据交互
  private string _name; 
  //属性公有化，属性是外界访问私有字段的入口，属性本身不保存任何数据
  public string Name{   
    //读取属性值，本质获取属性指向的私有字段的值
    get{ return _name}
    //给属性赋值，本质是给属性指向的私有字段赋值
    set{ _name = value}
  }

  private int _age; 
  public int Age{   
    get{ return _age}
    //添加业务逻辑
    set{
      if(_age<18){
        _age = 18;
      }else{
        _age = value
      }
    }
  }

  private int _address; 
  public int Address{  
    //只读 
    get{ return _address}
  }

  //自动属性,必须是标准属性 .NET 3.0 以后新增
  public DateTime Birthday{get; set;}
}

为什么定义了字段，还要定义属性？
属性可以添加业务逻辑，提高数据可靠性
属性可以设置只读、只写，提高数据安全性

ref

可以将值类型按照引用方式传递
out

让方法有多个返回值
构造方法

完成对象的初始化
对象初始化器

People people = new People(){
  Name = "张张"，
  Age = 12
}

装箱，拆箱

Object -> 值类型 -> 拆箱
值类型 -> Object -> 装箱
对象的动态排序

public class Student:IComparable<Student>{
  public int Id{get; set;}
  public string Name{get; set;}
  public int Age{get; set;}

  public int CompareTo(Student other){
    return other.Age - this.Age // 按照年龄降序
  }
}

//调用方法
stuList.Sort();

class ageAsc:IComparer<Student>{
  public int Compare(Student x, Student y){
    return x.Age.CompareTo(y.Age);
  }
}

//调用方法
stuList.Sort(new ageAsc());

继承多态

抽象类，抽象方法/虚方法
里氏替换：父类类型作为方法的参数类型；父类类型作为方法的返回值；

接口多态

接口类，接口实现类
实现方法：接口作为方法的参数类型；接口作为方法的返回值；

序列化、反序列化

public class Serializer
{
	 #region 文件序列化
	 /// <summary>
	 /// 将对象序列化为字符串
	 /// </summary>
	 /// <typeparam name="T">类型</typeparam>
	 /// <param name="t">实例</param>
	 /// <returns>字符串</returns>
	 public static string ObjectToString<T>(T t)
	 {
	     BinaryFormatter formatter = new BinaryFormatter();
	     using (MemoryStream stream = new MemoryStream())
	     {                
	         formatter.Serialize(stream, t);
	         string result = System.Text.Encoding.UTF8.GetString(stream.ToArray());
	         return result;
	     }
	 }
	
	 /// <summary>
	 /// 将对象序列化为文件
	 /// </summary>
	 /// <typeparam name="T">类型</typeparam>
	 /// <param name="t">实例</param>
	 /// <param name="path">存放路径</param>
	 public static void ObjectToFile<T>(T t, string path)
	 {
	     BinaryFormatter formatter = new BinaryFormatter();
	     using (FileStream stream = new FileStream(path, FileMode.OpenOrCreate))
	     {                
	         formatter.Serialize(stream, t);
	         stream.Flush();
	     }
	 }
	
	 /// <summary>
	 /// 将字符串反序列为类型
	 /// </summary>
	 /// <typeparam name="T">类型</typeparam>
	 /// <param name="s">字符串</param>
	 /// <returns>对象</returns>
	 public static T StringToObject<T>(string s) where T : class
	 {
	     byte[] buffer = System.Text.Encoding.UTF8.GetBytes(s);
	     BinaryFormatter formatter = new BinaryFormatter();
	     using (MemoryStream stream = new MemoryStream(buffer))
	     {                
	         T result = formatter.Deserialize(stream) as T;
	         return result;
	     }
	 }
	
	 /// <summary>
	 /// 将文件反序列化为对象
	 /// </summary>
	 /// <typeparam name="T">类型</typeparam>
	 /// <param name="path">路径</param>
	 /// <returns>对象</returns>
	 public static T FileToObject<T>(string path) where T : class
	 {
	     using (FileStream stream = new FileStream(path, FileMode.Open))
	     {
	         BinaryFormatter formatter = new BinaryFormatter();
	         T result = formatter.Deserialize(stream) as T;
	         return result;
	     }
	 }
	 #endregion
	
	/// <summary>
	/// 将对象序列化为xml文件
	/// </summary>
	/// <typeparam name="T">类型</typeparam>
	/// <param name="t">对象</param>
	/// <param name="path">xml存放路径</param>
	public static void ObjectToXml<T>(T t,string path) where T : class
	{
	 XmlSerializer formatter = new XmlSerializer(typeof(T));
	 using (FileStream stream = new FileStream(path, FileMode.OpenOrCreate))
	 {
	     formatter.Serialize(stream, t);
	 }
	}
	
	/// <summary>
	/// 将对象序列化为xml字符串
	/// </summary>
	/// <typeparam name="T">类型</typeparam>
	/// <param name="t">对象</param>
	public static string ObjectToXml<T>(T t) where T : class
	{
	 XmlSerializer formatter = new XmlSerializer(typeof(T));
	 using (MemoryStream stream = new MemoryStream())
	 {
	     formatter.Serialize(stream, t);
	     string result = System.Text.Encoding.UTF8.GetString(stream.ToArray());
	     return result;
	 }
	}
	
	/// <summary>
	/// 将xml文件反序列化为对象
	/// </summary>
	/// <typeparam name="T">类型</typeparam>
	/// <param name="t">对象</param>
	/// <param name="path">xml路径</param>
	/// <returns>对象</returns>
	public static T XmlToObject<T>(T t, string path) where T : class
	{
	 XmlSerializer formatter = new XmlSerializer(typeof(T));
	 using (FileStream stream = new FileStream(path, FileMode.OpenOrCreate))
	 {
	     XmlReader xmlReader = new XmlTextReader(stream);
	     T result = formatter.Deserialize(xmlReader) as T;
	     return result;
	 }
	} 

	/// 将对象序列化为json文件
	/// </summary>
	/// <typeparam name="T">类型</typeparam>
	/// <param name="t">实例</param>
	/// <param name="path">存放路径</param>
	public static void ObjectToJson<T>(T t, string path) where T : class
	{
	 DataContractJsonSerializer formatter = new DataContractJsonSerializer(typeof(T));
	 using (FileStream stream = new FileStream(path, FileMode.OpenOrCreate))
	 {
	     formatter.WriteObject(stream, t);
	 }
	}
	
	/// <summary>
	/// 将对象序列化为json字符串
	/// </summary>
	/// <typeparam name="T">类型</typeparam>
	/// <param name="t">实例</param>
	/// <returns>json字符串</returns>
	public static string ObjectToJson<T>(T t) where T : class
	{
	 DataContractJsonSerializer formatter = new DataContractJsonSerializer(typeof(T));
	 using (MemoryStream stream = new MemoryStream())
	 {
	     formatter.WriteObject(stream, t);
	     string result = System.Text.Encoding.UTF8.GetString(stream.ToArray());
	     return result;
	 }
	}
	
	/// <summary>
	/// json字符串转成对象
	/// </summary>
	/// <typeparam name="T">类型</typeparam>
	/// <param name="json">json格式字符串</param>
	/// <returns>对象</returns>
	public static T JsonToObject<T>(string json) where T : class
	{
	 DataContractJsonSerializer formatter = new DataContractJsonSerializer(typeof(Book));
	 using (MemoryStream stream = new MemoryStream(System.Text.Encoding.UTF8.GetBytes(json)))
	 {
	     T result = formatter.ReadObject(stream) as T;
	     return result;
	 }
	}  
}