原型模式java

『壹』 java創建對象

public class AreaAndLength{
public static void main(String args[]){
double length,area;
Circle circle=null;
Triang triang;
Ladder ladder;
}

public class Circle {
}
class Triang{

}
class Ladder{

}

}

如果只是建立類的話這樣就行，如果要通過類完成一些演算法或功能得自己通過需求編寫。

『貳』 java設計模式之Prototype(原型)

定義: 用原型實例指定創建對象的種類 並且通過拷貝這些原型創建新的對象 Prototype模式允許一個對象再創建另外一個可定製的對象 根本無需知道任何如何創建的細節 工作原理是:通過將一個原型對象傳給那個要發動創建的對象 這個要發動創建的對象通過請求原型對象拷貝它們自己來實施創建 如何使用? 因為Java中的提供clone()方法來實現對象的克隆(具體了解clone()按這里) 所以Prototype模式實現一下子變得很簡單 以勺子為例 public abstract class AbstractSpoon implements Cloneable{ String spoonName; public void setSpoonName(String spoonName) {this spoonName = spoonName;}public String getSpoonName() {return this spoonName;}public Object clone() {Object object = null;try {object = super clone();} catch (CloneNotSupportedException exception) {System err println( AbstractSpoon is not Cloneable );}return object;}} 有兩個具體實現(ConcretePrototype):public class SoupSpoon extends AbstractSpoon{ public SoupSpoon(){setSpoonName( Soup Spoon ); }}public class SaladSpoon extends AbstractSpoon{ public SaladSpoon(){setSpoonName( Salad Spoon ); }}調用Prototype模式很簡單:AbstractSpoon spoon = new SoupSpoon();AbstractSpoon spoon = new SaladSpoon(); 當然也可以結合工廠模式來創建AbstractSpoon實例 在Java中Prototype模式變成clone()方法的使用 由於Java的純潔的面向對象特性 使得在Java中使用設計模式變得很自然 兩者已經幾乎是渾然一體了 這反映在很多模式上 如Interator遍歷模式 lishixin/Article/program/Java/gj/201311/27354

『叄』 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）
原則是盡量使用合成/聚合的方式，而不是使用繼承。

『肆』 開發應用場景及順序

設計模式是被編程者總結出來的一套被反復使用的、多數人知曉的、經過分類編目的代碼設計經驗。掌握常用的設計模式對於Java應聘者來說十分重要，如單例模式、工廠模式、建造者模式等。接下來具體料及一下Java常用設計模式及應用場景：
1、單例模式：保證一個類僅有一個實例並提供一個全局訪問點，如一些配置文件或者管理類可以設計為單例，常用的線程池也是單例。
2、模板方法：在定義好的演算法骨架下允許子類為一個或多個步驟提供實現，一次性實現演算法的不變部分將可變部分留給子類實現，當子類實現代碼邏輯雷同時可以使用此設計模式。
3、工廠模式：創建對象需要大量的重復代碼時，通過子類實現方法來創建對象。如Spring中通過工廠模式將創建對象的任務交給容器管理。
4、原型模式 ：在應用程序可能有某些對象的結構比較復雜，但又需要頻繁的使用它們，如這個時候不斷的新建這個對象勢必會大大損耗系統內存的，這個時候需要使用原型模式來對這個結構復雜又要頻繁使用的對象進行克隆。所以原型模式就是用原型實例指定創建對象的種類，且通過復制這些原型創建新的對象。主要應用與那些創建新對象的成本過大時。它的主要優點就是簡化了新對象的創建過程，提高了效率，同時原型模式提供了簡化的創建結構。
5、建造者模式：講復雜對象的構建和表示分離，適用於流程固定，但是順序不一定固定的場景。如需要給一個對象多次給不同的屬性賦值，可以使用鏈式調用傳參，最後生成對象。如策略模式，觀察者模式，模板方法模式，foreach中的迭代器模式，spring 中ASM的訪問者模式，動態代理等都有一些了解。
6、適配器模式：在應用程序中可能需要將兩個不同介面的類來進行通信，在不修改這兩個的前提下可能會需要某個中間件來完成這個銜接的過程。這個中間件就是適配器。所謂適配器模式就是將一個類的介面，轉換成客戶期望的另一個介面。它可以讓原本兩個不兼容的介面能夠無縫完成對接。作為中間件的適配器將目標類和適配者解耦，增加了類的透明性和可復用性。
7、橋接模式 ：如果說某個系統能夠從多個角度來進行分類，且每一種分類都可能會變化，那麼我們需要做的就是講這多個角度分離出來，使得他們能獨立變化，減少他們之間的耦合，這個分離過程就使用了橋接模式。所謂橋接模式就是講抽象部分和實現部分隔離開來，使得他們能夠獨立變化。橋接模式將繼承關系轉化成關聯關系，封裝了變化，完成了解耦，減少了系統中類的數量，也減少了代碼量。
設計模式應用場景是什麼?JavaEE應用中Spring用於創建IOC容器的監聽器就是基於觀察者模式的。Spring中獲取FileSystemResource和ClassPathResource等功能雷同的類時使用模板方法。
單例模式包含懶漢餓漢式以及不同的變種，工廠類設計模式一般也設計為單例。項目中的一些配置或引入外部的sdk需要創建管理類，或封裝自己的框架時需要用到單例;工廠方法在編碼時不能預見需要創建哪種類的實例。
設計模式是一套被反復使用、多數人知曉、經過分類編目的、代碼設計經驗的總結。使用設計模式是為了可重用代碼、讓代碼更容易被他人理解、保證代碼可靠性。設計模式於己於他人於系統都是多贏，設計模式使代碼編制真正工程化，設計模式是軟體工程的基石。

『伍』 java面向對象如何創建對象

java作為互聯網編程中使用范圍最廣泛的編程語言之一，我們有許多的知識是需要掌握學習的，今天java課程培訓機構http://www.kmbdqn.cn/就給大家分析講解一下java面向對象的編程方法有哪些。

常用的創建對象的模式有以下幾種：

一.工廠模式

工廠模式抽象了具體對象的過程，用函數來封裝以特ing介面創建對象的細節。

如下：

functioncreateAnimal(name,age){

varo=newObject();

o.name=name;

o.age=age;

o.sayName=function(){

alert(this.name);

}

returno;

}

varcat=createAnimal("cat",12);

vardog=createAnimal("dog",3);

工廠模式雖然解決了創建多個相似兌現過的問題，但是卻沒有解決對象識別的問題。

二.構造函數模式

構造函數模式可以創建特定類型的對象。

functionAnimal(name,age){

this.name=name;

this.age=age;

this.sayName=function(){

alert(this.name);

}

}

varcat=newAnimal("cat",12);

vardog=newAnimal("dog",3);

可以使用對象的constructor屬性或instanceof操作符來標識對象類型。

cat.constructor==Animal//true

catinstanceofAnimal//true

三.原型模式

每個函數都有一個prototype(原型)屬性。這個屬性是一個指針，指向一個對象，而這個對象的用途是包含可以由特定類型的所有實例共享的屬性和方法。

使用原型對象的好處是，可以讓所有對象實例共享它所包含的屬性和方法。

functionAnimal(){}

Animal.prototype.name="animal";

Animal.prototype.age=1;

Animal.prototype.sayName=function(){

alert(this.name);

}

vartest1=newAnimal();

test1.sayName();//"animal"

vartest2=newAnimal();

test2.sayName();//"animal"

alert(test1.sayName===test2.sayName);//true

或者：

functionAnimal(){}

Animal.prototype={

constructor:Animal,

name:"animal",

age:1,

sayName:function(){

alert(this.name);

}

};

原型中所有屬性是被很多實例共享的，通過在實例上添加一個同名屬性，可以隱藏原型中的對應屬性。但是，對於包含引用類型值的屬性來說，問題就比較明顯了。

『陸』 java中抽象工廠模式和原型模式之間的區別

工廠模式的好處就在於將工廠和產品之間的耦合降低，將具體產品的構造過程放在了具體工廠類裡面。在以後擴展產品的時候方便很多，只需要添加一個工廠類，一個產品類，就能方便的添加產品，而不需要修改原有的代碼。而在簡單工廠中，如果要增加一個產品，則需要修改工廠類，增加if/else分支，或者增加一個case分支，工廠模式符合軟體開發中的OCP原則（open close principle），對擴展開放，對修改關閉。
抽象工廠模式：這個模式我總是感覺和builder模式非常相似。
工廠方法模式提供的是對一個產品的等級模式，，而抽象工廠方法提供的是對多個產品的等級模式，注意，這里的多個具體產品之間是相互耦合的，也就是說這里的抽象工廠提供的產品之間是存在某種聯系的。
有人做如下的比較：
工廠方法模式：一個抽象產品類，可以派生出多個具體產品類。
一個抽象工廠類，可以派生出多個具體工廠類。
每個具體工廠類只能創建一個具體產品類的實例。
抽象工廠模式：多個抽象產品類，每個抽象產品類可以派生出多個具體產品類。
一個抽象工廠類，可以派生出多個具體工廠類。
每個具體工廠類可以創建多個具體產品類的實例。
區別：工廠方法模式只有一個抽象產品類，而抽象工廠模式有多個。
工廠方法模式的具體工廠類只能創建一個具體產品類的實例，而抽象工廠模式可以創建多個。

『柒』 java中幾種常見的設計模式

一共23種設計模式！

按照目的來分，設計模式可以分為創建型模式、結構型模式和行為型模式。
創建型模式用來處理對象的創建過程；結構型模式用來處理類或者對象的組合；行為型模式用來對類或對象怎樣交互和怎樣分配職責進行描述。

創建型模式用來處理對象的創建過程，主要包含以下5種設計模式：
 工廠方法模式（Factory Method Pattern）
 抽象工廠模式（Abstract Factory Pattern）
 建造者模式（Builder Pattern）
 原型模式（Prototype Pattern）
 單例模式（Singleton Pattern）

結構型模式用來處理類或者對象的組合，主要包含以下7種設計模式：
 適配器模式（Adapter Pattern）
 橋接模式（Bridge Pattern）
 組合模式（Composite Pattern）
 裝飾者模式（Decorator Pattern）
 外觀模式（Facade Pattern）
 享元模式（Flyweight Pattern）
 代理模式（Proxy Pattern）

行為型模式用來對類或對象怎樣交互和怎樣分配職責進行描述，主要包含以下11種設計模式：
 責任鏈模式（Chain of Responsibility Pattern）
 命令模式（Command Pattern）
 解釋器模式（Interpreter Pattern）
 迭代器模式（Iterator Pattern）
 中介者模式（Mediator Pattern）
 備忘錄模式（Memento Pattern）
 觀察者模式（Observer Pattern）
 狀態模式（State Pattern）
 策略模式（Strategy Pattern）
 模板方法模式（Template Method Pattern）
 訪問者模式（Visitor Pattern）

推薦你一本好書：《軟體秘笈：設計模式那點事》，裡面講解的23中設計模式例子很生動，容易理解，還有JDK中設計模式應用情況，看了收獲挺大的！網路裡面搜「設計模式」，第一條中設計模式網路中就有首推該圖書，瀏覽量在20幾萬以上的，不會錯的。好東西大家一起分享！
祝你早日學會設計模式！

『捌』 java設計模式的兩大主題是什麼，

設計模式的兩大主題是系統復用與系統擴展。Java具有簡單性、面向對象、分布式、健壯性、安全性、平台獨立與可移植性、多線程、動態性等特點。Java可以編寫桌面應用程序、Web應用程序、分布式系統和嵌入式系統應用程序等。

(8)原型模式java擴展閱讀

由四方面組成：

（1）Java編程語言

（2）Java類文件格式

（3）Java虛擬機

（4）Java應用程序介面

當編輯並運行一個Java程序時，需要同時涉及到這四種方面。使用文字編輯軟體（例如記事本、寫字板、UltraEdit等）或集成開發環境（Eclipse、MyEclipse等）在Java源文件中定義不同的類 ，通過調用類（這些類實現了Java API）中的方法來訪問資源系統，把源文件編譯生成一種二進制中間碼，。

存儲在class文件中，然後再通過運行與操作系統平台環境相對應的Java虛擬機來運行class文件，執行編譯產生的位元組碼，調用class文件中實現的方法來滿足程序的Java API調用。

『玖』 java面試中主要掌握的設計模式有哪些

java面試
設計模式主要分三個類型:創建型、結構型和行為型。
其中創建型有：
一、Singleton，單例模式：保證一個類只有一個實例，並提供一個訪問它的全局訪問點
二、Abstract Factory，抽象工廠：提供一個創建一系列相關或相互依賴對象的介面，而無須指定它們的具體類。
三、Factory Method，工廠方法：定義一個用於創建對象的介面，讓子類決定實例化哪一個類，Factory Method使一個類的實例化延遲到了子類。
四、Builder，建造模式：將一個復雜對象的構建與他的表示相分離，使得同樣的構建過程可以創建不同的表示。
五、Prototype，原型模式：用原型實例指定創建對象的種類，並且通過拷貝這些原型來創建新的對象。
行為型有：
六、Iterator，迭代器模式：提供一個方法順序訪問一個聚合對象的各個元素，而又不需要暴露該對象的內部表示。
七、Observer，觀察者模式：定義對象間一對多的依賴關系，當一個對象的狀態發生改變時，所有依賴於它的對象都得到通知自動更新。
八、Template Method，模板方法：定義一個操作中的演算法的骨架，而將一些步驟延遲到子類中，TemplateMethod使得子類可以不改變一個演算法的結構即可以重定義該演算法得某些特定步驟。
九、Command，命令模式：將一個請求封裝為一個對象，從而使你可以用不同的請求對客戶進行參數化，對請求排隊和記錄請求日誌，以及支持可撤銷的操作。
十、State，狀態模式：允許對象在其內部狀態改變時改變他的行為。對象看起來似乎改變了他的類。
十一、Strategy，策略模式：定義一系列的演算法，把他們一個個封裝起來，並使他們可以互相替換，本模式使得演算法可以獨立於使用它們的客戶。
十二、China of Responsibility，職責鏈模式：使多個對象都有機會處理請求，從而避免請求的送發者和接收者之間的
開發模式:
JAVA中的開發模式:
MVC是一個很常用的程序開發設計模式，M-Model（模型）

『拾』 prototype的含義

我們知道JScript中對象的prototype屬性，是用來返回對象類型原型的引用的。我們使用prototype屬性提供對象的類的一組基本功能。並且對象的新實例會"繼承"賦予該對象原型的操作。但是這個prototype到底是怎麼實現和被管理的呢？

對於對象的prototype屬性的說明，JScript手冊上如是說：所有 JScript 內部對象都有隻讀的 prototype 屬性。可以向其原型中動態添加功能(屬性和方法)，但該對象不能被賦予不同的原型。然而，用戶定義的對象可以被賦給新的原型。

下面我們看三個經典的prototype屬性的使用示例。

1、為腳本環境內建對象添加方法：

程序代碼
Array.prototype.max = function()
{
var i, max = this[0];
for (i = 1; i < this.length; i++)
{
if (max < this[i])
max = this[i];
}
return max;
};

2、為用戶自定義類添加方法：

程序代碼
function TestObject(name)
{
this.m_Name = name;
}

TestObject.prototype.ShowName = function()
{
alert(this.m_Name);
};

3、更新自定義類的prototype：

程序代碼
function TestObjectA()
{
this.MethodA = function()
{
alert('TestObjectA.MethodA()');
}
}

function TestObjectB()
{
this.MethodB = function()
{
alert('TestObjectB.MethodB()');
}
}

TestObjectB.prototype = new TestObjectA();

第三個很眼熟吧？對啊，它就是我們前面介紹的原型繼承法呀~~ 不過今天我們不是研究"繼承"，之所以可以這樣來實現一種繼承，只是利用了prototype屬性的一個副作用而已。

prototype還有一個默認的屬性：constructor，是用來表示創建對象的函數的(即我們OOP里說的構造函數)。constructor屬性是所有具有prototype屬性的對象的成員。它們包括除Global和Math對象以外的所有JScript內部對象。constructor屬性保存了對構造特定對象實例的函數的引用。

弄清楚了JScript中prototype屬性怎麼使用後，下面我們再來深入的研究它。
上面的文章中我羅列了一下prototype屬性在JScript中的各種用法，但是prototype這個東西卻不是JScript創造出來的，JScript實際上是使用了我們設計模式中prototype pattern的一種衍生形式。下面我先簡單的說一下prototype pattern，然後再來看到底JScript中的prototype是怎麼回事?!

What's prototype pattern?

Specify the kinds of objects to create using a prototypical instance, and create new objects by ing this prototype.

用原型實例指定創建對象的種類，並且通過拷貝這些原型創建新的對象。

原型模式允許一個對象再創建另外一個可定製的對象，根本無需知道任何如何創建的細節，工作原理是：通過將一個原型對象傳給那個要發動創建的對象，這個要發動創建的對象通過請求原型對象拷貝它們自己來實施創建。

繼續了解到底什麼是prototype pattern，可以參看'設計模式之Prototype(原型)'這篇文章，即使不懂Java也沒有關系，把它的代碼都當C#看就行了。

搞清楚什麼是原型了吧？反正記著一點，prototype pattern是的實現是依賴於clone這個操作的，當然要shallow 還是deep 的clone看自己的需要了。

下面我們繼續說JScript里的prototype，為什麼我們說它和prototype pattern里的prototype不一樣呢?! 這個不是我說就說出來的，也不是我吹出來的，看看這個示例，你就能大概糊塗：

程序代碼
<script language="javascript">
function RP()
{
RP.PropertyA = 1;
RP.MethodA = function()
{
alert("RP.MethodA ");
};

this.PropertyA = 100;
this.MethodA = function()
{
alert("this.MethodA");
};
}

RP.prototype.PropertyA = 10;
RP.prototype.MethodA = function()
{
alert("RP.prototype.MethodA");
};
</script>

不要著急，還沒有開始做示例，只是給出了我們用來演示的一個類。RP是什麼？rpwt嗎？當然不是了，RP是ResearchPrototype了。好了不廢話了，看示例及結果分析。

程序代碼
<script language="javascript">
rp = new RP();
alert(RP.PropertyA);
RP.MethodA();
alert(rp.PropertyA);
rp.MethodA();
</script>

運行結果閃亮登場：
1
RP.MethodA
100
this.MethodA
這個%$@#^$%&^...，不要著急，繼續看哦！

程序代碼
<script language="javascript">
rp = new RP();
delete RP.PropertyA;
alert(RP.PropertyA);
delete RP.MethodA;
RP.MethodA();
delete rp.PropertyA;
alert(rp.PropertyA);
delete rp.MethodA;
rp.MethodA();
</script>
運行結果再次登場：

程序代碼
undefined
A Runtime Error has occurred.
Do you wish to Debug?
Line: 32
Error: Object doesn't support this property or method
10
RP.prototype.MethodA

好玩吧，看出來什麼名堂了嗎？這里的RP.PropertyA和RP.MethodA只是用來做參照的，可是怎麼把this.PropertyA和this.MethodA都delete了，還能出來結果，而且還是prototype導入的屬性和方法呢？

這就是JScript的prototype和prototype pattern中prototype最大的不同了，JScript中的這個所謂的prototype屬性其實是個語言本身支持的特性，這里沒有發生任何的，不管shallow還是deep的。對於JScript的解釋引擎，它在處理"."或"[keyName]"引用的對象的屬性和方法時，先在對象本身的實例(this)中查找，如果找到就返回或執行。如果沒有查找到，就查找對象的prototype(this.constructor.prototype)里是否定義了被查找的對象和方法，如果找到就返回或執行，如果沒有查找到，就返回undefined(對於屬性)或runtime error(對於方法)。

正因為prototype導入類實例的屬性或方法是動態查找的，所以我們才能對系統內部對象添加prototype屬性和方法，比如給String對象添加trim方法：

程序代碼
<script lanuage="javascript">
String.prototype.trim()
{
return this.replace(/(^\s+)|(\s+$)/g, "");
}
</scritp>

顯然JScript中的這種用法也是prototype pattern中的prototype不能解釋和支持的。

這下對於JScript OOP中原型繼承法的理解因該沒有任何的障礙了吧？同時也應該明白為什麼原型繼承法有那麼大的天生缺陷了吧？當然如果有任何問題，歡迎繼續討論。

附演示示例源代碼：

程序代碼
<html>
<head>
<meta name="author" content="birdshome@博客園">
<title>JScript Prototype Research</title>
</head>
<body>
<script language="javascript">
function RP()
{
RP.PropertyA = 1;
RP.MethodA = function()
{
alert("RP.MethodA ");
};

this.PropertyA = 100;
this.MethodA = function()
{
alert("this.MethodA");
};
}

RP.prototype.PropertyA = 10;
RP.prototype.MethodA = function()
{
alert("RP.prototype.MethodA");
};
</script>
<script language="javascript">
rp = new RP();
delete RP.PropertyA;
alert(RP.PropertyA);
delete RP.MethodA;
RP.MethodA();
delete rp.PropertyA;
alert(rp.PropertyA);
delete rp.MethodA;
rp.MethodA();
</script>
</body>
</html>