Prototype pattern

Prototype pattern

Sebuah prototype pattern adalah sebuah design pattern kreatif yang digunakan dalam pengembangan perangkat lunak. Jenis object untuk membuat object baru ditentukan oleh prototype contoh. Object di kloning untuk menghasilkan object baru.

Pattern ini digunakan untuk:

• menghindari subclass dari object kreator dalam aplikasi klien, tidak seperti abstract factory pattern.
• menghindari biaya yang melekat (inherent cost) dari object baru yang dibuat sesuai standar (misalnya, dengan menggunakan keyword 'new'), saat biaya itu cukup mahal untuk aplikasi tertentu.

Untuk mengimplementasikan pattern, deklarasikan sebuah abstract base class yang menentukan sebuah pure virtual clone () method. Setiap class yang memerlukan sebuah “polymorphic constructor”, maka kemampuan itu berasal dari class abstract base dirinya sendiri, dan mengimplementasikan operasi clone ().

Klien, bukanya menulis kode yang meminta operator "new" pada sebuah hard-coded class name, memanggil method clone () pada prototipe, memanggil sebuah factory method dengan sebuah parameter tertentu yang menunjuk particular concrete kelas turunan yang diinginkan, atau mengacu pada method clone () melalui beberapa mekanisme yang disediakan oleh design pattern lain.

Contoh

Prototype Pattern menentukan jenis object untuk membuat sebuah prototype contoh. Prototipe produk baru sering dibangun sebelum memproduksi masal, tetapi dalam contoh ini, prototype adalah pasif dan tidak berpartisipasi dalam menyalin diri sendiri.  Pembelahan mitosis sel - berakibat dua sel identik, dan ini adalah contoh dari prototipe yang memainkan peran aktif dalam menyalin dirinya sendiri dan hal ini menunjukkan Prototype pattern. Ketika sebuah sel membelah diri, maka dua sel yang identik hasil genotype akan tercipta. Dengan kata lain, sel tersebut meng-klon dirinya sendiri. [Michael Duell, "Non-software examples of software design patterns", Object Magazine, Jul 97, p54].

Java

/**

 * Prototype Class

 */

public class Cookie implements Cloneable {

    @Override

    public Cookie clone() throws CloneNotSupportedException {

        // call Object.clone()

        Cookie copy = (Cookie) super.clone();

        //In an actual implementation of this pattern you might now change references to

        //the expensive to produce parts from the copies that are held inside the prototype.

        return copy;

    }

}

/**

 * Concrete Prototypes to clone

 */

public class CoconutCookie extends Cookie { }

/**

 * Client Class

 */

public class CookieMachine {

    private Cookie cookie; // Could have been a private Cloneable cookie.

    public CookieMachine(Cookie cookie) {

        this.cookie = cookie;

    }

    public Cookie makeCookie() {

        return (Cookie) this.cookie.clone();

    }

    public static void main(String args[]) {

        Cookie tempCookie = null;

        Cookie prot = new CoconutCookie();

        CookieMachine cm = new CookieMachine(prot);

        for (int i = 0; i < 100; i++)

            tempCookie = cm.makeCookie();

    }

}

Python

import copy

#

# Prototype Class

#

class Cookie:

    def __init__(self, name):

        self.name = name

    def clone(self):

        return copy.deepcopy(self)

#

# Concrete Prototypes to clone

#

class CoconutCookie(Cookie):

    def __init__(self):

        Cookie.__init__(self, 'Coconut')

# Client Class

class CookieMachine:

    def __init__(self, cookie):

        self.cookie = cookie

    def make_cookie(self):

        return self.cookie.clone()

if __name__ == '__main__':

    prot = CoconutCookie()

    cm = CookieMachine(prot)

     for i in xrange(10):

        temp_cookie = cm.make_cookie()

Aturan yang perlu diperhatikan

Kadang-kadang creational patterns tumpang tindih - ada kasus-kasus ketika baik Prototype atau Abstract Factory akan sesuai. Di lain waktu mereka saling melengkapi satu sama lain: Abstract Factory mungkin menyimpan set Prototype dari yang untuk mengkloning dan produk kembali object (GOF, p126). Abstract Factory, Builder, dan Prototipe dapat menggunakan Singleton dalam implementasi. (GoF, p81, 134). (GOF, p81, 134). Abstract Factory classes sering dilaksanakan dengan Metode Pabrik (penciptaan melalui pewarisan), tetapi mereka dapat diimplementasikan dengan menggunakan Prototype (ciptaan melalui delegasi). (GoF, p95) (GOF, p95)

Sering kali, desain awal dengan menggunakan Metode Pabrik (kurang rumit, lebih disesuaikan, subclass berkembang biak) dan berkembang ke arah Abstract Factory, Prototype, atau Builder (lebih fleksibel, lebih kompleks) sebagai perancang menemukan di mana fleksibilitas lebih dibutuhkan. (GoF, p136) (GOF, p136)

Prototype tidak memerlukan subclassing, tapi itu tidak memerlukan sebuah "initialize" operasi. Metode factory  memerlukan subclassing, tapi tidak memerlukan inisialisasi. (GoF, p116) (GOF, p116)

Desain yang membuat penggunaan berat Composite dan decorator pattern sering dapat memperoleh manfaat dari Prototype juga. (GoF, p126) (GOF, p126)

Rule of thumb bisa jadi Anda akan perlu untuk mengkloning () sebuah Object ketika Anda ingin membuat Object lain pada saat runtime yang merupakan sebuah true copy Object kloning Anda. True copy berarti seluruh atribut yang baru dibuat harus Object yang sama dengan Object yang Anda kloning. Jika Anda bisa instantiated class dengan menggunakan bukan baru, Anda akan mendapatkan Object dengan semua atribut sebagai nilai awal. Sebagai contoh, jika Anda merancang suatu sistem untuk melakukan transaksi rekening bank, maka Anda akan ingin untuk membuat salinan dari Object yang memegang informasi account Anda, melakukan transaksi di atasnya, dan kemudian mengganti Object asli dengan yang diubah satu. Dalam kasus tersebut, Anda akan ingin menggunakan clone () bukan baru.