第三讲: 设计模式研究
OOP: 原则+设计模式+AOP
设计原则: 解决了程序编写的思路
设计模式: 程序开发中特定问题的方案总结
设计模式分类:
1:) 创建型设计模式: 研究对象的创建问题
一 简单工厂 ,解决了单一对象创建问题
二 抽象工厂 解决多组对象的创建问题
三 单例模式 ,对象创建中始终唯一
2:)结构型设计模式 (研究的是类一类之间的关系问题)
适配器模式,侨联模式....
3:行为型设计模式 研究对象和行为的分离
关于类:包含了属性和方法, 属性表示类的数据存储,方法表示类的各种操作
创建型: 研究"造"的问题 (对象的创建)
结构型: 研究"合"的问题(类和类的关系)
行为型: 研究"分"的问题(对象和行为的分离)
---------------------------------------------------------------------------------------------------------------------------------------------------------------.
对象直接的关系:
一:纵向 继续-->实现(父类-->子类), 接口-->实现
二:横向 关系由弱到强 ,依赖-->关联-->聚合-->组合 (关系链是我们研究的重点)
依赖关系:
namespace xike._1._1依赖关系
{
/// <summary>
/// 类和类之间的关系1:依赖关系
/// 特定:一个类中,"使用"到了另一个类,这种使用是临时的,较弱的关系
/// 典型的应用:一个类作为另一个类的方法的参数,或者这个方法的局部变量
/// </summary>
public class ClassA
{
public void Method1(ClassB b)
{
b.Test();
}
public void Method1(ClassB b)
{
ClassB b = new ClassB();
}
}
class ClassB
{
public void Test(){}
}
}
关联关系:
namespace xike._1._2关联关系
{
/// <summary>
/// 关联关系
/// 例如:比如客户和订单就是关联关系 (一个对象和另一个对象有关系,是客观的关系)
/// 特定:一个类中使用到了另一个类 ,这种使用是长期的,交强的关系
/// 典型应用: 一个类作为另一个类的成员 ,一对一(单一属性), 一对多(集合形式),
/// 组合形式: 单向, 双向,自关联
/// </summary>
public class ClassA
{
private ClassB clb; //单向关系
}
class ClassB
{
private List<ClassA> cla; //一对多 (ClassA和ClassB 是双向关系)
public void Test() { }
}
class ClassC
{
private ClassC clc; //自关联 (单例模式就是自关联)
}
}
聚合关系:
namespace xike._1.3聚合关系
{
/// <summary>
/// 聚合关系: 是关联关系的一种特例
/// 例如:汽车和发动机? 电脑和键盘 ?
/// 特定:虽然表示一个对象和另一个对象有关联,.但是对象之间是整体和部分关系,整体和部分可以分开
/// 典型应用: 一个对象作为另一个类的成员
/// 组合形式: 通过构造方法,或普通方法为这个成员赋值,对象是外边创建,然后传递过来
/// </summary>
public class ClassA
{
private ClassB clb;
public ClassA(ClassB b)
{
clb = b;
}
public ClassA()
{
}
public void setclb(ClassB b)
{
clb=b;
}
}
class ClassB
{
public void Test() { }
}
public class Classc
{
ClassB b=new ClassB();
//第一
ClassA caa=new ClassA(b);
//第二:
ClassA ca=new ClassA();
public void test()
{
ca.setclb(b);
}
}
}
组合关系:
namespace xike._1.4组合关系
{
/// <summary>
/// 组合关系:
/// 例如:人和手脚的关系
/// 特定:虽然表示一个对象和另一个对象有关联,.但是对象之间是整体和部分关系,整体和部分不可分开,整体和部分是共生死的
/// 典型应用: 一个对象作为另一个类的成员
/// 组合形式: 通过构造方法内,或普通方法内 ,直接创建,也不用传递
/// </summary>
public class ClassA
{
private ClassB clb;
public ClassA()
{
clb=new ClassB();
}
public void setclb(ClassB b)
{
clb=b;
}
}
class ClassB
{
public void Test() { }
}
}
继承关系,和实现关系,不上代码了
记忆方法:
1:依赖关系, 用完就扔(可以用可以不用)
2:关联 ,需要使用长期,扔不掉
3:集合 团队成员,大家关系比较紧密,但是并不是非谁不可
4.组合关系, 我们是一家,关系非常紧密,谁也不能缺少
----------------------------------------------------------------------------------单例模式------------------------------------------------------------------------------
单例模式: 在使用中,始终只有一个对象的实例, 基本方法,就是提供一个静态的访问点,保证只有一个实例,而不会重复创建
使用好处: 在特定的情况下,节省对象的创建资源,
应用场合: 高性能非关系型数据库,redis,... 底层的连接池
逻辑代码:
namespace danli
{
class Program
{
static void Main(string[] args)
{
//普通方式
Console.WriteLine("------------------------普通方式-----------------------------");
dla a = new dla();
a.Test();
dla b = new dla();
b.Test();
//单例模式 (创建一个使用静态变量,来保存当前实例,私有化构造函数,防止其他类直接创建,提供一个静态接入点返回实例)
Console.WriteLine("------------------------单利方法-----------------------------");
clb da = clb.GetIn();
da.Test();
clb db = clb.GetIn();
db.Test();
Console.WriteLine("------------------------单利方法(多线程调用)-----------------------------");
Task.Factory.StartNew(() =>
{
clc daa = clc.GetIn();
daa.Test();
});
Task.Factory.StartNew(() =>
{
clc dbb = clc.GetIn();
dbb.Test();
});
Console.Read();
}
#region 普通模式
class dla
{
public dla()
{
Console.WriteLine("构造函数运行" + DateTime.Now.ToLongTimeString());
Thread.Sleep(2000);
}
public void Test()
{
Console.WriteLine("方法运行" + DateTime.Now.ToLongTimeString());
}
}
#endregion
#region 单例模式 (类的关系是自关联) (这种单利如果是多线程就会有问题,创建可能是多次)
class clb
{
/// <summary>
/// 创建一个私有化静态对象,来保存当前实例
/// </summary>
private static clb dl = null;
/// <summary>
/// 私有化构造函数
/// </summary>
private clb()
{
Console.WriteLine("构造函数运行" + DateTime.Now.ToLongTimeString());
Thread.Sleep(2000);
}
/// <summary>
/// 提供一个静态接入点返回实例
/// </summary>
/// <returns></returns>
public static clb GetIn()
{
if (dl == null)
{
dl = new clb();
}
return dl;
}
public void Test()
{
Console.WriteLine("方法运行" + DateTime.Now.ToLongTimeString());
}
}
#endregion
#region 单利模式 (适合多线程的单利) 解决方案一
class clc
{
/// <summary>
/// 创建一个私有化静态对象,来保存当前实例
/// </summary>
private static clc dl = null;
/// <summary>
/// 私有化构造函数
/// </summary>
private clc()
{
Console.WriteLine("构造函数运行" + DateTime.Now.ToLongTimeString());
Thread.Sleep(2000);
}
private static object k = new object();
/// <summary>
/// 提供一个静态接入点返回实例
/// </summary>
/// <returns></returns>
public static clc GetIn()
{
if (dl == null)
{
lock (k)
{
if(dl==null)
{
dl = new clc();
}
}
}
return dl;
}
public void Test()
{
Console.WriteLine("方法运行" + DateTime.Now.ToLongTimeString());
}
}
#endregion
#region 单利模式 (适合多线程的单利) 解决方案二
class cld
{
/// <summary>
/// 创建一个私有化静态对象,来保存当前实例 (这个地方直接创建,本身就是线程安全的)
/// </summary>
private static cld dl = new cld();
/// <summary>
/// 私有化构造函数
/// </summary>
private cld()
{
Console.WriteLine("构造函数运行" + DateTime.Now.ToLongTimeString());
Thread.Sleep(2000);
}
private static object k = new object();
/// <summary>
/// 提供一个静态接入点返回实例
/// </summary>
/// <returns></returns>
public static cld GetIn()
{
return dl;
}
public void Test()
{
Console.WriteLine("方法运行" + DateTime.Now.ToLongTimeString());
}
}
#endregion
}
}
