代碼設計模式
A. 下面的代碼實現了設計模式中的什麼模式
一共23種設計模式! 引用《軟體秘笈-設計模式那點事》書籍: 按照目的來分,設計模... == null) { singleton = new Singleton(); }
B. 判斷以下代碼的設計模式
肯定是結構型模式的一種。
從樣子，可以是適配器模式、裝飾模式、橋接模式、組合模式等等
事實上這些模式從表現上來看(類的繼承結構)，都是基本一致的，但他們的動機以及側重點不同，因此很難從這段代碼上看出來確切是哪一種模式在使用。
如果能夠提供一些類的功能或者動機上的信息，判斷它所用的模式可能會更加容易。。
C. 急求java設計模式,要求用到兩種設計模式 求詳細代碼
.餓漢式單例類
//餓漢式單例類.在類初始化時，已經自行實例化
public class Singleton1 {
//私有的默認構造子
private Singleton1() {}
//已經自行實例化
private static final Singleton1 single = new Singleton1();
//靜態工廠方法
public static Singleton1 getInstance() {
return single;
}
}
2.懶漢式單例類
//懶漢式單例類.在第一次調用的時候實例化
public class Singleton2 {
//私有的默認構造子
private Singleton2() {}
//注意，這里沒有final
private static Singleton2 single=null;
//靜態工廠方法
public synchronized static Singleton2 getInstance() {
if (single == null) {
single = new Singleton2();
}
return single;
}
}
//對懶漢式單例的改進(錯誤的改進)
//實際上，只有在第一次創建對象的時候需要加鎖，之後就不需要了 ，這樣可以提升性能
public synchronized static Singleton2 getInstance() {
if (instance == null) {
synchronized(instance){ //鎖住當前實例對象
if(instance == null){
instance = new Singleton2();
}
}
}
return instance;
}
錯誤原因：
a>A、B線程同時進入了第一個if判斷
b>A首先進入synchronized塊，由於instance為null，所以它執行instance = new Singleton();
c>由於JVM內部的優化機制，JVM先畫出了一些分配給Singleton實例的空白內存，並賦值給instance成員（注意此時JVM沒有開始初始化這個實例），然後A離開了synchronized塊。
d>B進入synchronized塊，由於instance此時不是null，因此它馬上離開了synchronized塊並將結果返回給調用該方法的程序。
e>此時B線程打算使用Singleton實例，卻發現它沒有被初始化，於是錯誤發生了。
正確改進（使用內部類）：
JVM內部的機制能夠保證當一個類被載入的時候，這個類的載入過程是線程互斥的，JVM能夠幫我們保證instance只被創建一次，
並且會保證把賦值給instance的內存初始化完畢，這樣我們就不用擔心上面的問題。
同時該方法也只會在第一次調用的時候使用互斥機制，這樣就解決了低性能問題
public?class?Singleton?{??
??
/*?私有構造方法，防止被實例化?*/??
private?Singleton(){
}
/*?此處使用一個內部類來維護單例?*/??
private?static?class?SingletonFactory?{??
private?static?Singleton?instance?=?new?Singleton();??
}
/*?獲取實例?*/??
public?static?Singleton?getInstance()?{??
return?SingletonFactory.instance;??
}
/*?如果該對象被用於序列化，可以保證對象在序列化前後保持一致?*/??
public?Object?readResolve()?{??
return?getInstance();??
}
}
其實說它完美，也不一定，如果在構造函數中拋出異常，實例將永遠得不到創建，也會出錯？？？？
第二種改進：
因為我們只需要在創建類的時候進行同步，所以只要將創建和getInstance()分開，
單獨為創建加synchronized關鍵字，也是可以的
public class Singleton {
private static Singleton instance=null;
private Singleton(){}
private static synchronized void Init(){
if(instance==null)
instance=new Singletion();
}
public static Singleton getInstance(){
if(instance==null){
Init();
}
return instance;
}
}
3.登記式單例類
import java.util.HashMap;
import java.util.Map;
//登記式單例類.
//類似Spring裡面的方法，將類名注冊，下次從裡面直接獲取。
public class Singleton3 {
private static Map<String,Singleton3> map = new HashMap<String,Singleton3>();
static{
Singleton3 single = new Singleton3();
map.put(single.getClass().getName(), single);
}
//保護的默認構造子
protected Singleton3(){}
//靜態工廠方法,返還此類惟一的實例
public static Singleton3 getInstance(String name) {
if(name == null) {
name = Singleton3.class.getName();
System.out.println("name == null"+"--->name="+name);
}
if(map.get(name) == null) {
try {
map.put(name, (Singleton3) Class.forName(name).newInstance());
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
return map.get(name);
}
//一個示意性的商業方法
public String about() {
return "Hello, I am RegSingleton.";
}
public static void main(String[] args) {
Singleton3 single3 = Singleton3.getInstance(null);
System.out.println(single3.about());
}
}
D. 求一個含10種java設計模式的源代碼
具體要求：
1、項目概述：主要闡述項目的功能
2、概要設計：各個類的功能說明和成員函數功能說明以及類層次圖，重點要闡述設計各個類時，所使用的設計模式和各個模式下的類結構圖。
3、演算法描述或程序流程圖描述
4、關鍵代碼說明
5、運行與測試
。。。。。。。。還可以有其他部分
6、項目總結
發我郵箱 [email protected]
E. java 流程式代碼適合什麼設計模式
總體來說設計模式分為三大類：
創建型模式，共五種：工廠方法模式、抽象工廠模式、單例模式、建造者模式、原型模式。
結構型模式，共七種：適配器模式、裝飾器模式、代理模式、外觀模式、橋接模式、組合模式、享元模式。
行為型模式，共十一種：策略模式、模板方法模式、觀察者模式、迭代子模式、責任鏈模式、命令模式、備忘錄模式、狀態模式、訪問者模式、中介者模式、解釋器模式。
二、設計模式的六大原則
1、開閉原則（Open Close Principle）
開閉原則就是說對擴展開放，對修改關閉。在程序需要進行拓展的時候，不能去修改原有的代碼，實現一個熱插拔的效果。所以一句話概括就是：為了使程序的擴展性好，易於維護和升級。想要達到這樣的效果，我們需要使用介面和抽象類，後面的具體設計中我們會提到這點。
2、里氏代換原則（Liskov Substitution Principle）
里氏代換原則(Liskov Substitution Principle LSP)面向對象設計的基本原則之一。 里氏代換原則中說，任何基類可以出現的地方，子類一定可以出現。 LSP是繼承復用的基石，只有當衍生類可以替換掉基類，軟體單位的功能不受到影響時，基類才能真正被復用，而衍生類也能夠在基類的基礎上增加新的行為。里氏代換原則是對「開-閉」原則的補充。實現「開-閉」原則的關鍵步驟就是抽象化。而基類與子類的繼承關系就是抽象化的具體實現，所以里氏代換原則是對實現抽象化的具體步驟的規范。—— From Bai 網路
3、依賴倒轉原則（Dependence Inversion Principle）
這個是開閉原則的基礎，具體內容：真對介面編程，依賴於抽象而不依賴於具體。
4、介面隔離原則（Interface Segregation Principle）
這個原則的意思是：使用多個隔離的介面，比使用單個介面要好。還是一個降低類之間的耦合度的意思，從這兒我們看出，其實設計模式就是一個軟體的設計思想，從大型軟體架構出發，為了升級和維護方便。所以上文中多次出現：降低依賴，降低耦合。
5、迪米特法則（最少知道原則）（Demeter Principle）
為什麼叫最少知道原則，就是說：一個實體應當盡量少的與其他實體之間發生相互作用，使得系統功能模塊相對獨立。
6、合成復用原則（Composite Reuse Principle）
原則是盡量使用合成/聚合的方式，而不是使用繼承。
F. 你熟悉的設計模式有哪些寫出單例模式的實現代碼
23個設計模式：
根據目的設計模式可以分為創造模式，結構模式和行為模式，創建模式用於處理對象的創建。結構模式用於處理類或對象的組合。
行為模式用於描述類或對象如何交互以及如何分配職責，創建模式用於處理對象的創建。主要包括以下五種設計模式：
工廠方法模式（）
抽象工廠模式（AbstractFactoryPattern）
建造者模式（BuilderPattern）
原型模式（PrototypePattern）
單例模式（SingletonPattern）
結構模式用於處理類或對象的組合，包括以下七個設計模式：
適配器模式（AdapterPattern）
橋接模式（BridgePattern）
組合模式（CompositePattern）
裝飾者模式（DecoratorPattern）
外觀模式（FacadePattern）
享元模式（FlyweightPattern）
代理模式（ProxyPattern）
行為模式描述類或對象如何交互以及它們如何分配職責。它由以下11種設計模式組成：
責任鏈模式（Chain的ResponsibilityPattern）
命令模式（CommandPattern）
解釋器模式（InterpreterPattern）
迭代器模式（IteratorPattern）
中介者模式（MediatorPattern）
備忘錄模式（MementoPattern）
觀察者模式（ObserverPattern）
狀態模式（StatePattern）
策略模式（StrategyPattern）
模板方法模式（TemplateMethodPattern）
訪問者模式（VisitorPattern）
單例模式實現1：
公共類Singleton｛
類共享實例對象
私有靜態單例；單例＝零；
／／私有構造函數
私有Singleton（）｛
系統。出去了。這是單例！！）；
｝
／／獲取單例方法
公共同步靜態單例getInstance（）｛
／／確定共享對象是否為空，如何空一個新對象
If（singleton＝＝null）｛
singleton＝newsingleton（）；
｝
返回單例。
｝
｝
單例模式實現2：
公共類Singleton｛
類共享實例對象實例化
＝newSingleton（）；
／／私有構造函數
私有Singleton（）｛
系統：出去了，這是單例！！）；
｝
／／獲取單例方法
公共靜態單例getInstance（）｛
直接返回共享對象
返回單例。
｝
｝
(6)代碼設計模式擴展閱讀：
注意事項：
設計模式主要分三個類型：創建型和行為型。
Singleton：確保一個類只有一個實例，並為其提供一個全局訪問點
AbstractFactory：提供一個介面，用於創建一系列相關或相互依賴的對象，而無需指定它們的具體類。
FactoryMethod：定義一個用於創建對象的介面，並讓子類決定實例化哪個類。工廠方法將類的實例化延遲到子類。
Builder：將復雜對象的構造與其表示分離，使相同的構造過程可以創建不同的表示。
Prototype：指定要使用Prototype實例創建的對象的類型，並復制該原型來創建一個新對象。
Composite：將對象組合成樹狀結構，以表示整體各部分之間的關系。組合使用戶一致地使用單個對象和組合對象。
Facade：為子系統fa中的一組介面提供一致的介面。Ade提供了一個高級介面，使子系統更易於使用。
Proxy：為其他對象提供一個代理，以控制對該對象的訪問
Adapter：將一個介面類轉換為客戶想要的另一個介面類。適配器模式使那些由於介面不兼容而無法一起工作的類一起工作。
Decrator：式比子類化更靈活，可以為對象動態添加一些額外的職責。
Bridge：模式將抽象部分與其實現部分分離，以便它們可以獨立地更改。
Flyweight：享元模式
G. Java寫一套漂亮的代碼，哪些設計模式比較常用
對於代碼結構上，看起來漂亮起作用的模式，常用的策略模式，工廠模式，裝飾模式和觀察者模式吧。但也看情景，生搬硬套會顯得不夠簡潔的
H. web前端常見的代碼設計模式有哪些
常見代碼 function CreatePerson(name,age,sex) {
var obj = new Object();
obj.name = name;
obj.age = age;
obj.sex = sex;
obj.sayName = function(){
return this.name;
}
return obj;
}
var p1 = new CreatePerson("longen",'28','男');
var p2 = new CreatePerson("tugenhua",'27','女');
console.log(p1.name); // longen
console.log(p1.age); // 28
console.log(p1.sex); // 男
console.log(p1.sayName()); // longen
console.log(p2.name); // tugenhua
console.log(p2.age); // 27
console.log(p2.sex); // 女
console.log(p2.sayName()); // tugenhua
// 返回都是object 無法識別對象的類型 不知道他們是哪個對象的實列
console.log(typeof p1); // object
console.log(typeof p2); // object
console.log(p1 instanceof Object);