① 誰能介紹一下JAVA平台開發中最長用的幾種設計模式~最好是通俗一些的並且有實例的~500分酬謝
例子很另類,不過還比較好懂
工廠模式, 工廠方法模式,單例模式, 外觀(Facade)模式, 觀察者(Observer)模式,橋接(Bridge)模式都是比較常用的,不同的項目有不同的設計方向,可以參考的設計模式也不盡相同,沒有定數,只是上面這幾個模式用的比較多一些。
其他的模式我找了一下,都列出來了。
======================
Java常用的設計模式
創建型模式
1、FACTORY—追MM少不了請吃飯了,麥當勞的雞翅和肯德基的雞翅都是MM愛吃的東西,雖然口味有所不同,但不管你帶MM去麥當勞或肯德基,只管向服務員說「來四個雞翅」就行了。麥當勞和肯德基就是生產雞翅的Factory
工廠模式:客戶類和工廠類分開。消費者任何時候需要某種產品,只需向工廠請求即可。消費者無須修改就可以接納新產品。缺點是當產品修改時,工廠類也要做相應的冊返修改。如:如何創建及如何向客戶端提供。
2、BUILDER—MM最愛聽的就是「我愛你」這句話了,見到不同地方的MM,要能夠用她們的方言跟她說這句話哦,我有一個多種語言翻譯機,上面每種語言都有一個按鍵,見到MM我只要按對應的鍵,它就能夠用相應的語言說出「我愛你」這句話了,國外的MM也可以輕松搞掂,這就是我的「我愛你」builder。(這一定比美軍在伊拉克用的翻譯機好賣)
建造模式:將產品的內部表象和產品的生成過程分割開來,從而使一個建造過程生成具有不同的內部表象的產品對象。建造模式使得產品內部表象可以獨立的變化,客戶不必知道產品內部組成的細節。建造模式可以強制實行一種分步驟進行的建造過程。
3、FACTORY METHOD—請MM去麥當勞吃漢堡,不同的MM有不同的口味,要每個都記住是一件煩人的事情,我一般採用Factory Method模式,帶著MM到服務員那兒,說「要一個漢堡」,具體要什麼樣的漢堡呢,讓MM直接跟服務員說就行了。
工廠方法模式:核心工廠類不再負責所有產品的創建,而是將具體創建的工作交給子類去做,成為一個抽象工廠角色,僅負責給出具體工廠類必須實現的介面,而不接觸哪一個產品類應當被實例化這種細節。
4、PROTOTYPE—跟MM用QQ聊天,一定要說些深情的話語了,我搜集了好多肉麻的情話,需要時只要出來放到QQ裡面就行了,這就是我的情話prototype了。(100塊錢一份,你要不要)
原始模型模式:通過給出一個原型對象來指明所要創建的對象的類型,然後用復制這個原型對象的方法創建出更多同類型的對象。原始模型模式允許動態的增加或減少產品類,產品類不需要非得有任何事先確定的等級結構,原始模型模式適州顫飢用於任何的等級結構。缺點是每一個類都必須配備一個克隆方法。
5、SINGLETON—俺有6個漂亮的老婆,她們的老公都是我,我就是我們家裡的老公Sigleton,她們只要說道「老公」,都是指的同一個人,那就是我(剛才做了個夢啦,哪有這么好的事)
單例模式:單例模式確保某一個類只有一個實例,而且自行實例化並向整個系統提供這個實例單例模式。單例模式只洞鏈應在有真正的「單一實例」的需求時才可使用。
結構型模式
6、ADAPTER—在朋友聚會上碰到了一個美女Sarah,從香港來的,可我不會說粵語,她不會說普通話,只好求助於我的朋友kent了,他作為我和Sarah之間的Adapter,讓我和Sarah可以相互交談了(也不知道他會不會耍我)
適配器(變壓器)模式:把一個類的介面變換成客戶端所期待的另一種介面,從而使原本因介面原因不匹配而無法一起工作的兩個類能夠一起工作。適配類可以根據參數返還一個合適的實例給客戶端。
7、BRIDGE—早上碰到MM,要說早上好,晚上碰到MM,要說晚上好;碰到MM穿了件新衣服,要說你的衣服好漂亮哦,碰到MM新做的發型,要說你的頭發好漂亮哦。不要問我「早上碰到MM新做了個發型怎麼說」這種問題,自己用BRIDGE組合一下不就行了
橋梁模式:將抽象化與實現化脫耦,使得二者可以獨立的變化,也就是說將他們之間的強關聯變成弱關聯,也就是指在一個軟體系統的抽象化和實現化之間使用組合/聚合關系而不是繼承關系,從而使兩者可以獨立的變化。
8、COMPOSITE—Mary今天過生日。「我過生日,你要送我一件禮物。」「嗯,好吧,去商店,你自己挑。」「這件T恤挺漂亮,買,這條裙子好看,買,這個包也不錯,買。」「喂,買了三件了呀,我只答應送一件禮物的哦。」「什麼呀,T恤加裙子加包包,正好配成一套呀,小姐,麻煩你包起來。」「……」,MM都會用Composite模式了,你會了沒有?
合成模式:合成模式將對象組織到樹結構中,可以用來描述整體與部分的關系。合成模式就是一個處理對象的樹結構的模式。合成模式把部分與整體的關系用樹結構表示出來。合成模式使得客戶端把一個個單獨的成分對象和由他們復合而成的合成對象同等看待。
9、DECORATOR—Mary過完輪到Sarly過生日,還是不要叫她自己挑了,不然這個月伙食費肯定玩完,拿出我去年在華山頂上照的照片,在背面寫上「最好的的禮物,就是愛你的Fita」,再到街上禮品店買了個像框(賣禮品的MM也很漂亮哦),再找隔壁搞美術設計的Mike設計了一個漂亮的盒子裝起來……,我們都是Decorator,最終都在修飾我這個人呀,怎麼樣,看懂了嗎?
裝飾模式:裝飾模式以對客戶端透明的方式擴展對象的功能,是繼承關系的一個替代方案,提供比繼承更多的靈活性。動態給一個對象增加功能,這些功能可以再動態的撤消。增加由一些基本功能的排列組合而產生的非常大量的功能。
10、FACADE—我有一個專業的Nikon相機,我就喜歡自己手動調光圈、快門,這樣照出來的照片才專業,但MM可不懂這些,教了半天也不會。幸好相機有Facade設計模式,把相機調整到自動檔,只要對准目標按快門就行了,一切由相機自動調整,這樣MM也可以用這個相機給我拍張照片了。
門面模式:外部與一個子系統的通信必須通過一個統一的門面對象進行。門面模式提供一個高層次的介面,使得子系統更易於使用。每一個子系統只有一個門面類,而且此門面類只有一個實例,也就是說它是一個單例模式。但整個系統可以有多個門面類。
11、FLYWEIGHT—每天跟MM發簡訊,手指都累死了,最近買了個新手機,可以把一些常用的句子存在手機里,要用的時候,直接拿出來,在前面加上MM的名字就可以發送了,再不用一個字一個字敲了。共享的句子就是Flyweight,MM的名字就是提取出來的外部特徵,根據上下文情況使用。
享元模式:FLYWEIGHT在拳擊比賽中指最輕量級。享元模式以共享的方式高效的支持大量的細粒度對象。享元模式能做到共享的關鍵是區分內蘊狀態和外蘊狀態。內蘊狀態存儲在享元內部,不會隨環境的改變而有所不同。外蘊狀態是隨環境的改變而改變的。外蘊狀態不能影響內蘊狀態,它們是相互獨立的。將可以共享的狀態和不可以共享的狀態從常規類中區分開來,將不可以共享的狀態從類里剔除出去。客戶端不可以直接創建被共享的對象,而應當使用一個工廠對象負責創建被共享的對象。享元模式大幅度的降低內存中對象的數量。
12、PROXY—跟MM在網上聊天,一開頭總是「hi,你好」,「你從哪兒來呀?」「你多大了?」「身高多少呀?」這些話,真煩人,寫個程序做為我的Proxy吧,凡是接收到這些話都設置好了自動的回答,接收到其他的話時再通知我回答,怎麼樣,酷吧。
代理模式:代理模式給某一個對象提供一個代理對象,並由代理對象控制對源對象的引用。代理就是一個人或一個機構代表另一個人或者一個機構採取行動。某些情況下,客戶不想或者不能夠直接引用一個對象,代理對象可以在客戶和目標對象直接起到中介的作用。客戶端分辨不出代理主題對象與真實主題對象。代理模式可以並不知道真正的被代理對象,而僅僅持有一個被代理對象的介面,這時候代理對象不能夠創建被代理對象,被代理對象必須有系統的其他角色代為創建並傳入。
行為模式
13、CHAIN OF RESPONSIBLEITY—晚上去上英語課,為了好開溜坐到了最後一排,哇,前面坐了好幾個漂亮的MM哎,找張紙條,寫上「Hi,可以做我的女朋友嗎?如果不願意請向前傳」,紙條就一個接一個的傳上去了,糟糕,傳到第一排的MM把紙條傳給老師了,聽說是個老處女呀,快跑!
責任鏈模式:在責任鏈模式中,很多對象由每一個對象對其下家的引用而接
起來形成一條鏈。請求在這個鏈上傳遞,直到鏈上的某一個對象決定處理此請求。客戶並不知道鏈上的哪一個對象最終處理這個請求,系統可以在不影響客戶端的情況下動態的重新組織鏈和分配責任。處理者有兩個選擇:承擔責任或者把責任推給下家。一個請求可以最終不被任何接收端對象所接受。
14、COMMAND—俺有一個MM家裡管得特別嚴,沒法見面,只好藉助於她弟弟在我們倆之間傳送信息,她對我有什麼指示,就寫一張紙條讓她弟弟帶給我。這不,她弟弟又傳送過來一個COMMAND,為了感謝他,我請他吃了碗雜醬面,哪知道他說:「我同時給我姐姐三個男朋友送COMMAND,就數你最小氣,才請我吃面。」,:-(
命令模式:命令模式把一個請求或者操作封裝到一個對象中。命令模式把發出命令的責任和執行命令的責任分割開,委派給不同的對象。命令模式允許請求的一方和發送的一方獨立開來,使得請求的一方不必知道接收請求的一方的介面,更不必知道請求是怎麼被接收,以及操作是否執行,何時被執行以及是怎麼被執行的。系統支持命令的撤消。
15、INTERPRETER—俺有一個《泡MM真經》,上面有各種泡MM的攻略,比如說去吃西餐的步驟、去看電影的方法等等,跟MM約會時,只要做一個Interpreter,照著上面的腳本執行就可以了。
解釋器模式:給定一個語言後,解釋器模式可以定義出其文法的一種表示,並同時提供一個解釋器。客戶端可以使用這個解釋器來解釋這個語言中的句子。解釋器模式將描述怎樣在有了一個簡單的文法後,使用模式設計解釋這些語句。在解釋器模式裡面提到的語言是指任何解釋器對象能夠解釋的任何組合。在解釋器模式中需要定義一個代表文法的命令類的等級結構,也就是一系列的組合規則。每一個命令對象都有一個解釋方法,代表對命令對象的解釋。命令對象的等級結構中的對象的任何排列組合都是一個語言。
16、ITERATOR—我愛上了Mary,不顧一切的向她求婚。
Mary:「想要我跟你結婚,得答應我的條件」
我:「什麼條件我都答應,你說吧」
Mary:「我看上了那個一克拉的鑽石」
我:「我買,我買,還有嗎?」
Mary:「我看上了湖邊的那棟別墅」
我:「我買,我買,還有嗎?」
Mary:「你的小弟弟必須要有50cm長」
我腦袋嗡的一聲,坐在椅子上,一咬牙:「我剪,我剪,還有嗎?」
……
迭代子模式:迭代子模式可以順序訪問一個聚集中的元素而不必暴露聚集的內部表象。多個對象聚在一起形成的總體稱之為聚集,聚集對象是能夠包容一組對象的容器對象。迭代子模式將迭代邏輯封裝到一個獨立的子對象中,從而與聚集本身隔開。迭代子模式簡化了聚集的界面。每一個聚集對象都可以有一個或一個以上的迭代子對象,每一個迭代子的迭代狀態可以是彼此獨立的。迭代演算法可以獨立於聚集角色變化。
17、MEDIATOR—四個MM打麻將,相互之間誰應該給誰多少錢算不清楚了,幸虧當時我在旁邊,按照各自的籌碼數算錢,賺了錢的從我這里拿,賠了錢的也付給我,一切就OK啦,俺得到了四個MM的電話。
調停者模式:調停者模式包裝了一系列對象相互作用的方式,使得這些對象不必相互明顯作用。從而使他們可以鬆散偶合。當某些對象之間的作用發生改變時,不會立即影響其他的一些對象之間的作用。保證這些作用可以彼此獨立的變化。調停者模式將多對多的相互作用轉化為一對多的相互作用。調停者模式將對象的行為和協作抽象化,把對象在小尺度的行為上與其他對象的相互作用分開處理。
18、MEMENTO—同時跟幾個MM聊天時,一定要記清楚剛才跟MM說了些什麼話,不然MM發現了會不高興的哦,幸虧我有個備忘錄,剛才與哪個MM說了什麼話我都拷貝一份放到備忘錄裡面保存,這樣可以隨時察看以前的記錄啦。
備忘錄模式:備忘錄對象是一個用來存儲另外一個對象內部狀態的快照的對象。備忘錄模式的用意是在不破壞封裝的條件下,將一個對象的狀態捉住,並外部化,存儲起來,從而可以在將來合適的時候把這個對象還原到存儲起來的狀態。
19、OBSERVER—想知道咱們公司最新MM情報嗎?加入公司的MM情報郵件組就行了,tom負責搜集情報,他發現的新情報不用一個一個通知我們,直接發布給郵件組,我們作為訂閱者(觀察者)就可以及時收到情報啦
觀察者模式:觀察者模式定義了一種一隊多的依賴關系,讓多個觀察者對象同時監聽某一個主題對象。這個主題對象在狀態上發生變化時,會通知所有觀察者對象,使他們能夠自動更新自己。
20、STATE—跟MM交往時,一定要注意她的狀態哦,在不同的狀態時她的行為會有不同,比如你約她今天晚上去看電影,對你沒興趣的MM就會說「有事情啦」,對你不討厭但還沒喜歡上的MM就會說「好啊,不過可以帶上我同事么?」,已經喜歡上你的MM就會說「幾點鍾?看完電影再去泡吧怎麼樣?」,當然你看電影過程中表現良好的話,也可以把MM的狀態從不討厭不喜歡變成喜歡哦。
狀態模式:狀態模式允許一個對象在其內部狀態改變的時候改變行為。這個對象看上去象是改變了它的類一樣。狀態模式把所研究的對象的行為包裝在不同的狀態對象里,每一個狀態對象都屬於一個抽象狀態類的一個子類。狀態模式的意圖是讓一個對象在其內部狀態改變的時候,其行為也隨之改變。狀態模式需要對每一個系統可能取得的狀態創立一個狀態類的子類。當系統的狀態變化時,系統便改變所選的子類。
21、STRATEGY—跟不同類型的MM約會,要用不同的策略,有的請電影比較好,有的則去吃小吃效果不錯,有的去海邊浪漫最合適,單目的都是為了得到MM的芳心,我的追MM錦囊中有好多Strategy哦。
策略模式:策略模式針對一組演算法,將每一個演算法封裝到具有共同介面的獨立的類中,從而使得它們可以相互替換。策略模式使得演算法可以在不影響到客戶端的情況下發生變化。策略模式把行為和環境分開。環境類負責維持和查詢行為類,各種演算法在具體的策略類中提供。由於演算法和環境獨立開來,演算法的增減,修改都不會影響到環境和客戶端。
22、TEMPLATE METHOD——看過《如何說服女生上床》這部經典文章嗎?女生從認識到上床的不變的步驟分為巧遇、打破僵局、展開追求、接吻、前戲、動手、愛撫、進去八大步驟(Template method),但每個步驟針對不同的情況,都有不一樣的做法,這就要看你隨機應變啦(具體實現);
模板方法模式:模板方法模式准備一個抽象類,將部分邏輯以具體方法以及具體構造子的形式實現,然後聲明一些抽象方法來迫使子類實現剩餘的邏輯。不同的子類可以以不同的方式實現這些抽象方法,從而對剩餘的邏輯有不同的實現。先制定一個頂級邏輯框架,而將邏輯的細節留給具體的子類去實現。
23、VISITOR—情人節到了,要給每個MM送一束鮮花和一張卡片,可是每個MM送的花都要針對她個人的特點,每張卡片也要根據個人的特點來挑,我一個人哪搞得清楚,還是找花店老闆和禮品店老闆做一下Visitor,讓花店老闆根據MM的特點選一束花,讓禮品店老闆也根據每個人特點選一張卡,這樣就輕松多了;
訪問者模式:訪問者模式的目的是封裝一些施加於某種數據結構元素之上的操作。一旦這些操作需要修改的話,接受這個操作的數據結構可以保持不變。訪問者模式適用於數據結構相對未定的系統,它把數據結構和作用於結構上的操作之間的耦合解脫開,使得操作集合可以相對自由的演化。訪問者模式使得增加新的操作變的很容易,就是增加一個新的訪問者類。訪問者模式將有關的行為集中到一個訪問者對象中,而不是分散到一個個的節點類中。當使用訪問者模式時,要將盡可能多的對象瀏覽邏輯放在訪問者類中,而不是放到它的子類中。訪問者模式可以跨過幾個類的等級結構訪問屬於不同的等級結構的成員類。
② 哪位大神可以提供k-prototype演算法的matlab代碼用於文本聚類的。
聚類演算法,不是分類演算法。分類演算法是給一個數據,然後判斷這個數據屬於已分好的類中握坦的具體哪一類。聚類演算法是給一大堆原始數據,然後通過演算法將其中具有相似特徵的數據聚為一類慧皮猜。
K-Means演算法的基本思想是初始隨機給定K個簇中心,按照最鄰近原則把待分類樣本點分到各個簇。然後按平均法重新計算各個簇的質心,從而確定新的簇心。一直迭代,直到簇心的移動距離小於某個給定的值。
演算法大致思路:
1、從給定樣本中任選幾個點作為初始中心(我取k=2)
2、計算其餘點分別和初始中心點的距離,跟哪個初始中心近就跟那個中心點歸為一類(歐式距離公式),直到各自為「派別」
3、在分好類的基礎上按平均值的方法重新計算聚類中心點,再重復第二步...以此類推
4、直到最後演算法收斂(可以理前型解為中心點不再變動)則結束。
③ 設計模式都有哪些
總體來說設計模式分為三大類:
一、創建型模式,共五種:工廠方法模式、抽象工廠模式、單例模式、建造者模式、原型模式。
二、結構型模式,共七種:適配器模式、裝飾器模式、代理模式、外觀模式、橋接模式、組合模式、享元模式。
三、行為型模式,共十一種:策略模式、模板方法模式、觀察者模式、迭代子模式、責任鏈模式、命令模式、備忘錄模式、狀態模式、訪問者模式、中介者模式、解釋器模式。
1、工廠方法模式:
定義一個用於創建對象的介面,讓子類決定實例化哪一個類。Factory Method 使一個類的實例化延遲到其子類。
工廠模式有一個問題就是,類的創建依賴工廠類,也就是說,如果想要拓展程序,必須對工廠類進行修改,這違背了閉包原則,所以,從設計角度考慮,有一定的問題,這就用到工廠方法模式。
創建一個工廠介面和創建多個工廠實現類,這樣一旦需要增加新的功能,直接增加新的工廠類就可以了,不需要修改之前的代碼。
2、抽象工廠模式:
提供一個創建一系列相關或相互依賴對象的介面,而無需指定它們具體的類。抽象工廠需要創建一些列產品,著重點在於"創建哪些"產品上,也就是說,如果你開發,你的主要任務是劃分不同差異的產品線,並且盡量保持每條產品線介面一致,從而可以從同一個抽象工廠繼承。
3、單例模式:
單例對象(Singleton)是一種常用的設計模式。在Java應用中,單例對象能保證在一個JVM中,該對象只有一個實例存在。這樣的模式有幾個好處:
(1)某些類創建比較頻繁,對於一些大型的對象,這是一筆很大的系統開銷。
(2)省去了new操作符,降低了系統內存的使用頻率,減輕GC壓力。
(3)有些類如交易所的核心交易引擎,控制著交易流程,如果該類可以創建多個的話,系統完全亂了。(比如一個軍隊出現了多個司令員同時指揮,肯定會亂成一團),所以只有使用單例模式,才能保證核心交易伺服器獨立控制整個流程。
4、建造者模式:
將一個復雜對象的構建與它的表示分離,使得同樣的構建過程可以創建不同的表示。
5、原型模式:
原型模式雖然是創建型的模式,但是與工程模式沒有關系,從名字即可看出,該模式的思想就是將一個對象作為原型,對其進行復制、克隆,產生一個和原對象類似的新對象。本小結會通過對象的復制,進行講解。在Java中,復制對象是通過clone()實現的,先創建一個原型類。
6、適配器模式:
適配器模式將某個類的介面轉換成客戶端期望的另一個介面表示,目的是消除由於介面不匹配所造成的類的兼容性問題。主要分為三類:類的適配器模式、對象的適配器模式、介面的適配器模式。
7、裝飾器模式:
顧名思義,裝飾模式就是給一個對象增加一些新的功能,而且是動態的,要求裝飾對象和被裝飾對象實現同一個介面,裝飾對象持有被裝飾對象的實例。
8、代理模式:
代理模式就是多一個代理類出來,替原對象進行一些操作,比如我們在租房子的時候回去找中介,為什麼呢?因為你對該地區房屋的信息掌握的不夠全面,希望找一個更熟悉的人去幫你做,此處的代理就是這個意思。
9、外觀模式:
外觀模式是為了解決類與類之家的依賴關系的,像spring一樣,可以將類和類之間的關系配置到配置文件中,而外觀模式就是將他們的關系放在一個Facade類中,降低了類類之間的耦合度,該模式中沒有涉及到介面。
10、橋接模式:
橋接模式就是把事物和其具體實現分開,使他們可以各自獨立的變化。橋接的用意是:將抽象化與實現化解耦,使得二者可以獨立變化,像我們常用的JDBC橋DriverManager一樣。
JDBC進行連接資料庫的時候,在各個資料庫之間進行切換,基本不需要動太多的代碼,甚至絲毫不用動,原因就是JDBC提供統一介面,每個資料庫提供各自的實現,用一個叫做資料庫驅動的程序來橋接就行了。
11、組合模式:
組合模式有時又叫部分-整體模式在處理類似樹形結構的問題時比較方便。使用場景:將多個對象組合在一起進行操作,常用於表示樹形結構中,例如二叉樹,數等。
12、享元模式:
享元模式的主要目的是實現對象的共享,即共享池,當系統中對象多的時候可以減少內存的開銷,通常與工廠模式一起使用。
13、策略模式:
策略模式定義了一系列演算法,並將每個演算法封裝起來,使其可以相互替換,且演算法的變化不會影響到使用演算法的客戶。需要設計一個介面,為一系列實現類提供統一的方法,多個實現類實現該介面,設計一個抽象類(可有可無,屬於輔助類),提供輔助函數。
14、模板方法模式:
一個抽象類中,有一個主方法,再定義1...n個方法,可以是抽象的,也可以是實際的方法,定義一個類,繼承該抽象類,重寫抽象方法,通過調用抽象類,實現對子類的調用。
15、觀察者模式:
觀察者模式很好理解,類似於郵件訂閱和RSS訂閱,當我們瀏覽一些博客或wiki時,經常會看到RSS圖標,就這的意思是,當你訂閱了該文章,如果後續有更新,會及時通知你。
其實,簡單來講就一句話:當一個對象變化時,其它依賴該對象的對象都會收到通知,並且隨著變化!對象之間是一種一對多的關系。
16、迭代子模式:
顧名思義,迭代器模式就是順序訪問聚集中的對象,一般來說,集合中非常常見,如果對集合類比較熟悉的話,理解本模式會十分輕松。這句話包含兩層意思:一是需要遍歷的對象,即聚集對象,二是迭代器對象,用於對聚集對象進行遍歷訪問。
17、責任鏈模式:
責任鏈模式,有多個對象,每個對象持有對下一個對象的引用,這樣就會形成一條鏈,請求在這條鏈上傳遞,直到某一對象決定處理該請求。但是發出者並不清楚到底最終那個對象會處理該請求,所以,責任鏈模式可以實現,在隱瞞客戶端的情況下,對系統進行動態的調整。
18、命令模式:
命令模式的目的就是達到命令的發出者和執行者之間解耦,實現請求和執行分開。
19、備忘錄模式:
主要目的是保存一個對象的某個狀態,以便在適當的時候恢復對象,個人覺得叫備份模式更形象些,通俗的講下:假設有原始類A,A中有各種屬性,A可以決定需要備份的屬性,備忘錄類B是用來存儲A的一些內部狀態,類C呢,就是一個用來存儲備忘錄的,且只能存儲,不能修改等操作。
20、狀態模式:
狀態模式在日常開發中用的挺多的,尤其是做網站的時候,我們有時希望根據對象的某一屬性,區別開他們的一些功能,比如說簡單的許可權控制等。
21、訪問者模式:
訪問者模式把數據結構和作用於結構上的操作解耦合,使得操作集合可相對自由地演化。訪問者模式適用於數據結構相對穩定演算法又易變化的系統。因為訪問者模式使得演算法操作增加變得容易。
若系統數據結構對象易於變化,經常有新的數據對象增加進來,則不適合使用訪問者模式。訪問者模式的優點是增加操作很容易,因為增加操作意味著增加新的訪問者。訪問者模式將有關行為集中到一個訪問者對象中,其改變不影響系統數據結構。其缺點就是增加新的數據結構很困難。
22、中介者模式:
中介者模式也是用來降低類類之間的耦合的,因為如果類類之間有依賴關系的話,不利於功能的拓展和維護,因為只要修改一個對象,其它關聯的對象都得進行修改。
如果使用中介者模式,只需關心和Mediator類的關系,具體類類之間的關系及調度交給Mediator就行,這有點像spring容器的作用。
23、解釋器模式:
解釋器模式一般主要應用在OOP開發中的編譯器的開發中,所以適用面比較窄。
(3)prototype演算法擴展閱讀:
介紹三本關於設計模式的書:
1、《設計模式:可復用面向對象軟體的基礎》
作者:[美] Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides
出版社: 機械工業出版社
2、《軟體秘笈:設計模式那點事》
作者:鄭阿奇
出版社:電子工業出版社
3、《設計模式:基於C#的工程化實現及擴展》
作者:王翔
出版社:電子工業出版社
④ 一文總結聚類分析步驟!
一、聚類
1.准備工作
(1) 研究目的
聚類分析是根據事物本身的特性研究個體分類的方法,聚類分析的原則是同一類別的個體有較大相似性,不同類別的個體差異比較大。
(2) 數據類型
1)定量:數字有比較意義,比如數字越大代表滿意度越高,量表為典型定量數據。
2)定類:數字無比較意義,比如性別,1代表男,2代表女。
PS: SPSSAU會根據數據類型自動選擇聚類方法。
K-modes聚類: 數據類型僅定類時。
2.上傳數據到SPSSAU
登錄賬號後進入SPSSAU頁面,點擊右上角「上傳數據」,將處理好的數據進行「點擊上傳文件」上傳即可。
3.SPSSAU操作
(1)拖拽分析項
1) SPSSAU進階方法→聚類。
2)檢查
檢查分析項是否都在左側分析框中。
3)進行拖拽
(2)選擇參數
聚類個數: 聚類個數設置為幾類主要以研究者的研究思路為標准,如果不進行設置,SPSSAU默認聚類個數為3,通常情況下,建議設置聚類數量介於3~6個之間。
標准化: 聚類演算法是根據距離進行判斷類別,因此一般需要在聚類之前進行標准化處理,SPSSAU默認是選中進行標准化處理。數據標准化之後,數據的相對大小意義還在(比如數字越大GDP越高),但是實際意義消失了。
保存類別: 分析選擇保存『保存類別』,SPSSAU會生成 新標題 用於標識,也可以右上角「我的數據」處查看到分析後的「聚類類別」。
新標題類似如下:Cluster_********。
4.SPSSAU分析
(1)聚類類別基本情況匯總分析
使用聚類分析對樣本進行分類,使用Kmeans聚類分析方法,從上表可以看出:最終聚類得到4類群體,此4類群體的佔比分別是20.00%, 30.00%, 20.00%, 30.00%。整體來看, 4類人群分布較為均勻,整體說明聚類效果較好。
(2)聚類類別匯總圖分析
上圖可以直觀的看到各個類別所佔百分比,4類群體的佔比分別是20.00%, 30.00%, 20.00%, 30.00%。
(3)聚類類別方差分析差異對比
使用方差分析去探索各個類別的差異特徵,從上表可知:聚類類別群體對於所有研究項均呈現出顯著性(p<0.05),意味著聚類分析得到的4類群體,他們在研究項上的特徵具有明顯的差異性,具體差異性可通過平均值進行對比,並且最終結合實際情況,對聚類類別進行命名處理。
(4)聚類項重要性對比
從上述結果看,所有研究項均呈現出顯著性,說明不同類別之間的特徵有明顯的區別,聚類的效果較好。
(5)聚類中心
5.其它說明
(1)聚類中心是什麼?
聚類中心是聚類類別的中心點情況,比如某類別時年齡對應的聚類中心為20,意味著該類別群體年齡基本在20歲左右。初始聚類中心基本無意義,它是聚類演算法隨機選擇的聚類點,如果需要查看聚類中心情況,需要關注於最終聚類中心。實際分析時聚類中心的意義相對較小,其僅為聚類演算法的計算值而已。
(2)k-prototype聚類是什麼?
如果說聚類項中包括定類項,那麼SPSSAU默認會進行K-prototype聚類演算法(而不是kmeans演算法)。定類數據不能通過數字大小直接分析距離,因而需要使用K-prototype聚類演算法。
(3)聚類分析時SSE是什麼意思?
在進行Kmeans聚類分析時SPSSAU默認輸出誤差平方和SSE值,該值可用於測量各點與中心點的距離情況,理論上是希望越小越好,而且如果同樣的數據,聚類類別越多則SSE值會越小(但聚類類別過多則不便於分析)。
SSE指標可用於輔助判斷聚類類別個數,建議在不同聚類類別數量情況下記錄下SSE值,然後分析SSE值的減少幅度情況,如果發現比如從3個聚類到4個類別時SSE值減少幅度明顯很大,那麼此時選擇4個聚類類別較好。
二、分層聚類
1.准備工作
(1)研究目的
從分析角度上看,聚類分析可分為兩種,一種是按樣本(或個案)聚類,此類聚類的代表是K-means聚類方法;另外一種是按變數(或標題)聚類,此類聚類的代表是分層聚類。
(2)數據類型
2.上傳數據到SPSSAU
登錄賬號後進入SPSSAU頁面,點擊右上角「上傳數據」,將處理好的數據進行「點擊上傳文件」上傳即可。
3.SPSSAU操作
(1)拖拽分析項
1) SPSSAU進階方法→分層聚類。
2)檢查
檢查分析項是否都在左側分析框中。
3)進行拖拽
(2)確定參數
SPSSAU會默認聚類為3類並且呈現表格結果,如果希望更多的類別個數,可自行進行設置。
4.SPSSAU分析
(1)聚類項描述分析
上表格展示總共8個分析項(即8個裁判數據)的基本情況,包括均值,最大或者最小值,中位數等,以便對於基礎數據有個概括性了解。整體上看,8個裁判的打分基本平均在8分以上。
(2)聚類類別分布表分析
總共聚類為3個類別,以及具體分析項的對應關系情況。在上表格中展示出來,上表格可以看出:裁判8單獨作為一類;裁判5,3,7這三個聚為一類;以及裁判1,6,2,4作為一類。
(PS:聚類類別與分析項上的對應關系可以在上表格中得到,同時也可以查看聚類樹狀圖得出更多信息。至於聚類類別分別應該叫做什麼名字,這個需要結合對應有關系情況,自己單獨進行命名。)
(3)聚類樹狀圖分析
上圖為聚類樹狀圖的展示,聚類樹狀圖是將聚類的具體過程用圖示法手法進行展示;最上面一行的數字僅僅是一個刻度單位,代表相對距離大小;一個結點表示一次聚焦過程。
樹狀圖的解讀上,建議單獨畫一條垂直線,然後對應查看分成幾個類別,以及每個類別與分析項的對應關系。比如上圖中,紅色垂直線最終會拆分成3個類別;第1個類別對應裁判8;第2個類別對應裁判5,3,7;第3個類別對應裁判1,6,2,4。
如果是聚為四類;從上圖可看出,明顯的已經不再合適。原因在於垂直線不好區分成四類。也即說明有2個類別本應該在一起更合適(上圖中的裁判1與6/2/4);但是如果分成4類,此時裁判1會單獨成一類。所以畫垂直線無法區分出類別。因而綜合分析來看,最終聚類為3個類別最為適合。
當然在分析時也可以考慮分成2個類別,此時只需要對應將垂直線移動即可。
5.其它說明
(1)針對分層聚類,需要注意以下幾點:
(2)什麼時候做因子分析後再做聚類分析?
如果題項較多,可先做因子分析,得到每個維度(因子)的數據,再進行聚類。
三、總結
聚類分析廣泛的應用於自然科學、社會科學等領域。在分析時可以比較多次聚類結果,綜合選擇更適合的方案。
以上就是聚類分析步驟匯總,更多干貨請前往官網查看!
⑤ js原生語法之prototype,__proto__和constructor
1前言寫了幾篇vue的源碼注釋(並不算解析...),感覺到了對原型的理解是不夠的,在js中,原型是非常重要的,只要你想在js這座山上往上爬,它就會嘲笑你,你把我搞會了么?如果沒有,它就給你加個十倍重力.如果搞懂了,那肯定是能月薪過萬,贏取白富美,走向人生巔峰的啦~~~
這篇文章講的都是我自己的理解,應該是原創的(我有99%把握,除非是我之前看過文章記到腦子里了,沒法給到引用了,聯系我可以加上),但是如果有人借鑒我的這篇文章,希望給到一個這篇文章的鏈接.其實我只是想我的文章能有更多的閱讀量,我想月薪過萬,贏取白富美,走向人生巔峰~~~
2前置知識點2.1數據類型js共有7種數據類型
從可不可以讀取屬性,可以分為兩類
可以讀取屬性:
自身可以有屬性:object
自身不可以有屬性:string,number,boolean,symbol
不可以讀取屬性:null,undefined
null,undefined類型,讀取和設置屬性都是非法的,直接報錯.
只有object能有自有屬性,可以讀取屬性和設置屬性
string,number,boolean,symbol類型可以讀取屬性,其實是先構造成包裝對象,再讀取屬性,設置屬性也是一樣,可以理解設置到了會立即銷毀的包裝對象上,就是可以設置,但是沒有任何實質效果.
2.2判斷是否是自身屬性(hasOwnProperty)hasOwnProperty方法是繼承來的,用來判斷該對象自身上是否有這個屬性,有就行,不管是什麼值
constobj={a:1}consto=Object.create(obj)o.b=1o.c=void0console.log('a',o.a,o.hasOwnProperty('a'))//可以讀取到值,繼承而來,但不是自身屬性console.log('b',o.b,o.hasOwnProperty('b'))//可以讀取到值,自身屬性console.log('c',o.c,o.hasOwnProperty('c'))//讀取到undefined,自身屬性console.log('d',o.d,o.hasOwnProperty('d'))//讀取到undefined,不是自身屬性,也沒有繼承到這個屬性程序就是數據結構與演算法,好的程序最好是使用最小的內存存儲數據,使用最快的時間完成運行得到結果.
復用數據可以達到減少內存使用的目的,例如a和b需要完成一樣的功能,就可以復用同一個方法(屬性).
那麼就需要解決一個問題,這個復用的方法存在哪裡,a和b怎樣能找到它.
在js中的解決方案是,a和b都由函數(這里先叫Function吧)構造而來,復用的方法存放在函數身上(prototype屬性里).
(因為只有構造函數身上需要存放復用的方法,所以prototype只有可構造的函數上才有,箭頭函數不是用來構造的,它就沒有,其它對象,如果連函數都不是,就更不會有這個屬性了)
那麼需要給a,b和Function建立起聯系,因為a,b需要到Function身上找它們可以用的復用方法
在js中的實現是通過constructor屬性,即a.constructor,b.constructor可以找到Function
所以通過a.constructor.prototype可以找到它可以復用的方法的存放地址,為了快速找到js提供了一種快捷方法a.__proto__一步到位找到,即a.constructor.prototype和a.__proto__找到的是同一個對象,當然它倆是全等的啦.
//它倆都不是自有屬性,我也不知道怎麼從這倆屬性上找到原型對象的了,肯定是魔法.....constobj={}console.log(obj.hasOwnProperty('__proto__'))//falseconsole.log(obj.hasOwnProperty('constructor'))//false(所以,如果手動修改了constructor,prototype,__proto__的指向,那麼你得清楚你在干什麼)
(我不知道js的設計者是不是這樣想的,哈哈,我就這樣認為,這樣好理解多了)
(這個過程稱之為繼承,而且是一個鏈式過程,即可以a.constructor.prototype.constructor.prototype.constructor.prototype這樣查找,直到找到最頂端,這個過程可以由a.__proto__.__proto__.__proto__加速,這個就叫做原型鏈,js的繼承只有這一種實現方式.)
(上面只是引導思考過程,其實查找原型對象並不會通過a.constructor.prototype去找,而是直接通過__proto__查找)
3.1修改constructorconstDog=function(){}constdog=newDog()dog.constructor=0console.log(dog.hasOwnProperty('constructor'))//trueconsole.log(dog.constructor)//0console.log(dog.__proto__.constructor)//[Function:Dog]總結,修改了這個屬性,增加了找到構造它的構造函數的難度,不能直接獲取了,需要到原型對象上去讀取.
如果它自身的這個屬性和原型上的這個屬性都被修改了,那麼也只是找不到它的構造函數了而已,不會有別的影響.
3.1.1instanceofinstanceof關心的是原型鏈,跟constructor沒有關系
印證上面的點,修改constructor屬性,除了讓實例找不到構造它的構造函數,沒有別的影響了.如果需要通過實例找到它的構造函數,就需要維護好它倆的關系.
//語法是//ainstanceofb//這個操作符是判斷a的原型鏈上是否有b.prototype,因為要判斷b.prototype所以b必需是一個可構造的函數,否則會報錯constfn=function(){}consto=Object.create(fn.prototype)//此時o的原型鏈上有fn.prototype,因為o.__proto__===fn.prototypeconsole.log(oinstanceoffn)//trueconstemptyObj={}fn.prototype=emptyObj//此時o的原型鏈上已經沒有fn.prototype了,因為此時o.__proto__已經不再和fn.prototype相等了console.log(oinstanceoffn)//falseo.__proto__=emptyObj//修正了o.__proto__就好了console.log(oinstanceoffn)//true3.1.2isPrototypeOf現在有個新的api,實現的功能和instanceof一致,但是更加語義化一些,直接判斷對象是否在另一個對象的原型鏈上
constfn=function(){}consto=Object.create(fn.prototype)console.log(fn.prototype.isPrototypeOf(o))//true3.2修改__proto__|prototype先說一個總結,在構造實例的時候,會將這個實例的__proto__指向此時的構造函數的prototype,然後實例實際是繼承的是__proto__.(為什麼強調此時,因為構造函數的prototype可能會被修改指向,修改之後只會影響修改之後構造的實例,修改之前構造的實例還會使用修改之前的prototype)
所以,就可以理解到修改__proto__和prototype會有哪些影響了
修改__proto__的指向
只會影響它自己的繼承
constDog=function(){}constdog=newDog()constd=newDog()Dog.prototype.name='Dog'dog.__proto__={name:'__proto__',}console.log(d.name)//Dogconsole.log(dog.name)//__proto__修改__proto__的屬性
會影響這一波段構造的實例
constDog=function(){}constdog=newDog()constd=newDog()Dog.prototype.name='Dog'console.log(d.name)//Dogconsole.log(dog.name)//DogDog.prototype={name:'after',}constdog1=newDog()constd1=newDog()console.log(d1.name)//afterconsole.log(dog1.name)//afterdog1.__proto__.name='__proto__'//可以看到隻影響了當前這一段構造的實例,之前和之後的都不會被影響到,因為這一段內的是同一個Dog.prototype,它們的__proto__都是指向它的console.log(d1.name)//__proto__console.log(dog1.name)//__proto__Dog.prototype={name:'new',}constdog2=newDog()constd2=newDog()console.log(d2.name)//newconsole.log(dog2.name)//new修改prototype的指向
會影響這一波段構造的實例
修改prototype的屬性
會影響這一波段構造的實例,同修改__proto__的屬性
4修改和獲取原型對象的方式4.1修改上面已經講了修改prototype和__proto__
4.1.1Object.createconstobj={name:'objName',}consto=Object.create(obj)//它相當於o.__proto__=obj,但是推薦使用`Object.create`console.log(o.name)//objNameconsole.log(o.__proto__===obj)//true4.1.2Object.setPrototypeOfconstobj={name:'objName',}consto={}Object.setPrototypeOf(o,obj)//它相當於o.__proto__=obj,但是推薦使用`Object.setPrototypeOf`constproto=Object.getPrototypeOf(o)console.log(proto===obj&&proto===o.__proto__)//trueconstobj1={}o.__proto__=obj1constproto1=Object.getPrototypeOf(o)console.log(proto1===obj1&&proto1===o.__proto__)//true總結,在什麼時候使用Object.create,在什麼時候使用Object.setPrototypeOf呢,首先它倆都是標准api,都是建議使用的,在創建對象的時候就要指定原型時使用Object.create,需要動態修改原型對象時,使用Object.setPrototypeOf
4.2獲取之前已經講了,通過constructor.prototype和__proto__獲取了
4.2.1Object.getPrototypeOfconstobj={name:'objName',}consto={}Object.setPrototypeOf(o,obj)constproto=Object.getPrototypeOf(o)console.log(proto===obj&&proto===o.__proto__)//true5js內置原生構造函數這些原生的構造函數的prototype屬性是不可寫,不可枚舉,不可配置的
//它倆都不是自有屬性,我也不知道怎麼從這倆屬性上找到原型對象的了,肯定是魔法.....constobj={}console.log(obj.hasOwnProperty('__proto__'))//falseconsole.log(obj.hasOwnProperty('constructor'))//false05.1js繼承的最頂端是什麼null,必須是這傢伙,不然只能無限套娃了
然後其它所有對象都是從Object構造而來,所以所有的對象都可以繼承到Object.prototype.
//它倆都不是自有屬性,我也不知道怎麼從這倆屬性上找到原型對象的了,肯定是魔法.....constobj={}console.log(obj.hasOwnProperty('__proto__'))//falseconsole.log(obj.hasOwnProperty('constructor'))//false15.2js繼承的二等公民(Function)在上面的小思考中,說到,js對象都是函數構造而來,所以包括Object也是由Function構造來的,甚至它自己都是由自己構造而來
//它倆都不是自有屬性,我也不知道怎麼從這倆屬性上找到原型對象的了,肯定是魔法.....constobj={}console.log(obj.hasOwnProperty('__proto__'))//falseconsole.log(obj.hasOwnProperty('constructor'))//false2我再來一點小理解,可能是在js內部做了小處理,第一個Function是憑空變出來的....然後這個Function構造出了Object,然後這個Object構造出了第一個原型對象Object.prototype,然後再去修改一些引用關系.
其實最復雜的是Object和Function的關系
//它倆都不是自有屬性,我也不知道怎麼從這倆屬性上找到原型對象的了,肯定是魔法.....constobj={}console.log(obj.hasOwnProperty('__proto__'))//falseconsole.log(obj.hasOwnProperty('constructor'))//false35.3js繼承的三等公民(內置的其他構造函數)//它倆都不是自有屬性,我也不知道怎麼從這倆屬性上找到原型對象的了,肯定是魔法.....constobj={}console.log(obj.hasOwnProperty('__proto__'))//falseconsole.log(obj.hasOwnProperty('constructor'))//false46用戶定義的特定公民構造函數這個才是重點,根據上面的理解,我會再開一篇文章寫一下我理解的js的繼承,這里就先留個坑
7.總結這篇文章跟網上大多講constructor,prototype,__proto__的文章都有所不同,我的立足點是從給定的一個可以讀取屬性的值開始,在js中,除了null和undefined,其它所有的值都可以成為立足點.從這個立足點開始,它的__proto__屬性記錄了它的原型對象,這個原型對象是構造它時,它的構造函數的prototype屬性的值。
//它倆都不是自有屬性,我也不知道怎麼從這倆屬性上找到原型對象的了,肯定是魔法.....constobj={}console.log(obj.hasOwnProperty('__proto__'))//falseconsole.log(obj.hasOwnProperty('constructor'))//false5讀取一個值的屬性的值時,如果它自身有這個屬性,那麼直接返回這個屬性的值,否則就會到它的__proto__對象上去找,一直遞歸下去,直到找到頂部null,找到就返回它的值,沒找到就返回undefined
這篇文章有三個理解點,讓我茅塞頓開,都是在我試驗了好久突然得到的結論:
以一個值為立足點開始分析
在構造實例的時候,會將這個實例__proto__指向此時的構造函數的prototype
查找原型對象時,以__proto__為准