Design patterns
Wzór prototypu
Szukaj…
Wprowadzenie
Wzór prototypowy to wzór kreacyjny, który tworzy nowe obiekty poprzez klonowanie istniejącego obiektu prototypowego. Prototypowy wzór przyspiesza tworzenie instancji klas, gdy kopiowanie obiektów jest szybsze.
Uwagi
Prototypowy wzór to kreatywny wzór projektowy. Jest używany, gdy rodzaj tworzonych obiektów jest określony przez prototypową instancję, która jest „klonowana” w celu wytworzenia nowych obiektów.
Ten wzorzec jest używany, gdy klasa potrzebuje „konstruktora polimorficznego (kopiującego)” .
Wzór prototypowy (C ++)
class IPrototype {
public:
virtual ~IPrototype() = default;
auto Clone() const { return std::unique_ptr<IPrototype>{DoClone()}; }
auto Create() const { return std::unique_ptr<IPrototype>{DoCreate()}; }
private:
virtual IPrototype* DoClone() const = 0;
virtual IPrototype* DoCreate() const = 0;
};
class A : public IPrototype {
public:
auto Clone() const { return std::unique_ptr<A>{DoClone()}; }
auto Create() const { return std::unique_ptr<A>{DoCreate()}; }
private:
// Use covariant return type :)
A* DoClone() const override { return new A(*this); }
A* DoCreate() const override { return new A; }
};
class B : public IPrototype {
public:
auto Clone() const { return std::unique_ptr<B>{DoClone()}; }
auto Create() const { return std::unique_ptr<B>{DoCreate()}; }
private:
// Use covariant return type :)
B* DoClone() const override { return new B(*this); }
B* DoCreate() const override { return new B; }
};
class ChildA : public A {
public:
auto Clone() const { return std::unique_ptr<ChildA>{DoClone()}; }
auto Create() const { return std::unique_ptr<ChildA>{DoCreate()}; }
private:
// Use covariant return type :)
ChildA* DoClone() const override { return new ChildA(*this); }
ChildA* DoCreate() const override { return new ChildA; }
};
To pozwala skonstruować klasę pochodną ze wskaźnika klasy bazowej:
ChildA childA;
A& a = childA;
IPrototype& prototype = a;
// Each of the following will create a copy of `ChildA`:
std::unique_ptr<ChildA> clone1 = childA.Clone();
std::unique_ptr<A> clone2 = a.Clone();
std::unique_ptr<IPrototype> clone3 = prototype.Clone();
// Each of the following will create a new default instance `ChildA`:
std::unique_ptr<ChildA> instance1 = childA.Create();
std::unique_ptr<A> instance2 = a.Create();
std::unique_ptr<IPrototype> instance3 = prototype.Create();
Wzór prototypu (C #)
Wzorzec prototypu można zaimplementować za pomocą interfejsu ICloneable w .NET.
class Spoon {
}
class DessertSpoon : Spoon, ICloneable {
...
public object Clone() {
return this.MemberwiseClone();
}
}
class SoupSpoon : Spoon, ICloneable {
...
public object Clone() {
return this.MemberwiseClone();
}
}
Wzór prototypowy (JavaScript)
W klasycznych językach, takich jak Java, C # lub C ++, zaczynamy od utworzenia klasy, a następnie możemy tworzyć nowe obiekty z klasy lub rozszerzać klasę.
W JavaScript najpierw tworzymy obiekt, a następnie możemy go ulepszyć lub stworzyć z niego nowe obiekty. Myślę więc, że JavaScript pokazuje rzeczywisty prototyp niż język klasyczny.
Przykład:
var myApp = myApp || {};
myApp.Customer = function (){
this.create = function () {
return "customer added";
}
};
myApp.Customer.prototype = {
read: function (id) {
return "this is the customer with id = " + id;
},
update: function () {
return "customer updated";
},
remove: function () {
return "customer removed";
}
};
Tutaj tworzymy obiekt o nazwie Customer , a następnie bez tworzenia nowego obiektu rozszerzyliśmy istniejący Customer object za pomocą słowa kluczowego prototyp . Ta technika jest znana jako wzór prototypowy .