設計模式源碼

㈡ 單例模式代碼怎麼寫

單例模式(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