设计模式源码

㈡ 单例模式代码怎么写

单例模式(Singleton) ,属于最常见的设计模式之一，大部分系统都会用到，目的是为了维护系统中唯一的一个实例。
可分为eager模式，示例代码如下：
Java代码
1.class EagerSingleton{
2. private static final EagerSingleton m_instance = new EagerSingleton();
3. private EagerSingleton(){}
4. public static EagerSingleton getInstance(){
5. return m_instance;
6. }
7.}
class EagerSingleton{
private static final EagerSingleton m_instance = new EagerSingleton();
private EagerSingleton(){}
public static EagerSingleton getInstance(){
return m_instance;
}
}
和 lazy模式，示例代码如下：
Java代码
1.class LazySingleton{
2. private static LazySingleton m_instance = null;
3. private LazySingleton(){}
4. public synchronized static getInstance(){
5. if(m_instance == null){
6. m_instance = new LazySingleton();
7. }
8. return m_instance;
9. }
10.}
class LazySingleton{
private static LazySingleton m_instance = null;
private LazySingleton(){}
public synchronized static getInstance(){
if(m_instance == null){
m_instance = new LazySingleton();
}
return m_instance;
}
}
java源码中，Runtime.getRuntime()就是单例的一个例子。
单例模式的精神就是整个系统中维护一个实例，推广开来，如果在一个系统中需要维护多个示例，那么就产生了多例模式(multiton)。
多例模式(Multiton) ,通过聚集对象了保留自身的多个示例，根据客户端的参数返回所需要的实例。
示例代码如下：
Java代码
1.class Multiton{
2. private final int INSTANCE_SIZE = 10;
3. private static Map instances = new HashMap(INSTANCE_SIZE);
4. private String name;
5. private Multiton(){}
6. private Multiton(String name){
7. this.name = name;
8. }
9. public synchronized static getInstance(String name){
10. if(instances.containsKey(name)){
11. return instances.get(name);
12. }
13. else{
14. ins = new Multiton(name);
15. instances.put(name, ins);
16. return ins;
17. }
18. }
19.}
class Multiton{
private final int INSTANCE_SIZE = 10;
private static Map instances = new HashMap(INSTANCE_SIZE);
private String name;
private Multiton(){}
private Multiton(String name){
this.name = name;
}
public synchronized static getInstance(String name){
if(instances.containsKey(name)){
return instances.get(name);
}
else{
ins = new Multiton(name);
instances.put(name, ins);
return ins;
}
}
}
[nextpage]
一个实用的例子就是KeyGenerator, 示例代码如下：
Java代码
1.class KeyGenerator{
2. private final int POOL_SIZE = 20;
3. private static Map instances = new HashMap(16);
4. private KeyInfo keyinfo;
5. private KeyGenerator(){}
6. private KeyGenerator(String keyName){
7. this.keyinfo = new KeyInfo(POOL_SIZE, keyName);
8. }
9. public synchronized static getInstance(String keyName){
10. if(instances.containsKey(keyName)){
11. return (KeyGenerator)instances.get(keyName);
12. }
13. else{
14. keyGen = new KeyGenerator(keyName);
15. instances.put(name, keyGen);
16. return keyGen;
17. }
18. }
19. public synzhronized int getNextKey(){
20. return keyinfo.getNextKey();
21. }
22. }
class KeyGenerator{
private final int POOL_SIZE = 20;
private static Map instances = new HashMap(16);
private KeyInfo keyinfo;
private KeyGenerator(){}
private KeyGenerator(String keyName){
this.keyinfo = new KeyInfo(POOL_SIZE, keyName);
}
public synchronized static getInstance(String keyName){
if(instances.containsKey(keyName)){
return (KeyGenerator)instances.get(keyName);
}
else{
keyGen = new KeyGenerator(keyName);
instances.put(name, keyGen);
return keyGen;
}
}
public synzhronized int getNextKey(){
return keyinfo.getNextKey();
}
}

㈢ 老师要求要任意三种不同的设计模式来实现一个系统的设计，俄罗斯方块也行，最好是JAVA源码跪求，急用

我这里有一个
俄罗斯方块
的，但是还没有做完，如果你需要可以发给你，就差几个简单的功能就可以完成了，但是
我没时间
做了。有一些复杂的功能可以不做，不过如果你看代码估计会比较麻烦，需要留qq

㈣ 老师要求要任意三种不同的设计模式来实现一个系统的设计，俄罗斯方块也行，最好是JAVA源码跪求，急用

我这里有一个俄罗斯方块的，但是还没有做完，如果你需要可以发给你，就差几个简单的功能就可以完成了，但是我没时间做了。有一些复杂的功能可以不做，不过如果你看代码估计会比较麻烦，需要留qq

㈤ 设计模式 c++ 源代码 举例

singleton模式

class ClassA
{
private:
int data;
static ClassA* ap;
protected:
ClassA(){};
public:
int Getdata();
int Setdata(int m_data);
static ClassA *Instance();
~ClassA();
};
int ClassA::Getdata()
{
return data;
}
int ClassA::Setdata(int m_data)
{
data = m_data;
return m_data;
}
ClassA* ClassA::Instance()
{
if(ap == NULL)//未被初始化
ap = new ClassA;
//ap = (ClassA*)malloc(sizeof(ClassA));
return ap;
}
ClassA::~ClassA()
{
delete ap;
}

ClassA* ClassA::ap = NULL;

int main(void)
{

ClassA *instance_a;
instance_a = ClassA::Instance();
int d = instance_a->Getdata();
cout<<d<<endl;

system("pause");
return 0;
}

㈥ 研读源码以及学习设计模式的问题

我工作了才一年多，不知道能不能帮到你。
以下都是我的个人理解：
1、框架约束了程序员的编程方式，提高了代码的复用性、灵活性。
2、不同领域业务的框架式不同，即没有一个万能的框架
3、好的框架除了第一点以外还有低侵入性，即从A框架转移至B框架或取消框架只需修改几个类或者几行代码
4、Spring框架的亮点是AOP编程，实现采用了动态生成代码的Emit技术
5、参与了实际的项目后才会真正知道这个框架到底哪些地方不足、怎么优化提高
6、大师们出了很多书，他们都是从实践中总结得出一些结论。而我们是从结论再去实践，势必有误差，所以还是找机会多参与项目吧

㈦ 设计模式，责任链模式，求java源码

importjava.io.*;
classPurchaseRequest{

publicdoubleAmount;
publicintNumber;
publicStringPurpose;
};

classApprover{

publicApprover(){successor=null;}

publicvoidProcessRequest(PurchaseRequestaRequest){
if(successor!=null){successor.ProcessRequest(aRequest);}
}

publicvoidSetSuccessor(ApproveraSuccessor){successor=aSuccessor;}

privateApproversuccessor;

};

classCongressextendsApprover{

publicvoidProcessRequest(PurchaseRequestaRequest){
if(aRequest.Amount<500000){
System.out.println("Congressisprocessing");
}
elsesuper.ProcessRequest(aRequest);
}
}

classPresidentextendsApprover{

publicvoidProcessRequest(PurchaseRequestaRequest){
if(aRequest.Amount>=500000){
System.out.println("Presidentisprocessing");
}
elsesuper.ProcessRequest(aRequest);
}
}

{

publicvoidProcessRequest(PurchaseRequestaRequest){
if(aRequest.Amount<100000){
System.out.println("VicePresidentisprocessing");
}
elsesuper.ProcessRequest(aRequest);
}
}

classDirectorextendsApprover{

publicvoidProcessRequest(PurchaseRequestaRequest){
if(aRequest.Amount<50000){
System.out.println("Directorisprocessing");
}
elsesuper.ProcessRequest(aRequest);
}
}


publicclassrs
{
publicstaticvoidmain(String[]args)throwsIOException{
CongressMeeting=newCongress();
PresidentTammy=newPresident();
VicePresidentSam=newVicePresident();
DirectorLarry=newDirector();
//
Meeting.SetSuccessor(null);
Tammy.SetSuccessor(Meeting);
Sam.SetSuccessor(Tammy);
Larry.SetSuccessor(Sam);

PurchaseRequestaRequest=newPurchaseRequest();
BufferedReaderbr=newBufferedReader(newInputStreamReader(System.in));
aRequest.Amount=Double.parseDouble(br.readLine());
Larry.ProcessRequest(aRequest);
}
}

hadoop@slave1:~/java$ javac rs.java

hadoop@slave1:~/java$ java rs

1

Director is processing

hadoop@slave1:~/java$ java rs

50000

VicePresident is processing

hadoop@slave1:~/java$ java rs

100000

Congress is processing

hadoop@slave1:~/java$ java rs

500000

President is processing

㈧ vuejs源码用了什么设计模式，具体点的

最简单的订阅者模式

// Observer
class Observer {
constructor (data) {
this.walk(data)
}
walk (data) {
// 遍历
let keys = Object.keys(data)
for(let i = 0; i < keys.length; i++){
defineReactive(data, keys[i], data[keys[i]])
}
}
}

function defineReactive (data, key, val) {
observer(val)

// dep 为什么要在这里实例化, 就是为了实现, 对象每一层的 每一个key都有自己的一个订阅实例, 比如 a.b 对应 dep1, a.c 对应dep2, 这里虽然都是let dep = new Dep()
// 但每次来到这个方法, dep都是独立的, 会一直保留在内存. 这样在每次调用set方法都能找到这个a.b对应的dep
// dep 这里会一直保存, 是因为闭包的关系, Object这个全局的函数, 引用了上层的作用域, 这个作用域包含了 dep, 除非Object = null, 或者退出浏览器, dep才会消失

//实例化之后, dep就有了被订阅, 和发布消息的功能, dep不写在这里也是可以的, 多定义一个全局函数, 每次obser的时候增加一个dep
let dep = new Dep()
Object.defineProperty(data, key, {
enumerable: true,
configurable: true,
get: function () {
//每次new Watch('a.b'), 都会先执行get方法, 进而来到这里, 触发 dep.depend(), 这个dep就是 a.b 对应的 订阅,
dep.depend()
return val
},
set: function (newVal) {
if(val === newVal){
return