Design patterns
Prototypmönster
Sök…
Introduktion
Prototypmönstret är ett kreativt mönster som skapar nya objekt genom att klona existerande prototypobjekt. Prototypmönstret påskyndar inställningen av klasser när kopiering av objekt går snabbare.
Anmärkningar
Prototypmönstret är ett kreativt mönster. Det används när typen av objekt som ska skapas bestäms av en prototypisk instans, som "klonas" för att producera nya objekt.
Detta mönster används när en klass behöver en "polymorf (kopia) konstruktör" .
Prototypmönster (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; }
};
Det gör det möjligt att konstruera den härledda klassen från en basklasspekare:
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();
Prototypmönster (C #)
Prototypmönstret kan implementeras med det ICloneable gränssnittet i .NET.
class Spoon {
}
class DessertSpoon : Spoon, ICloneable {
...
public object Clone() {
return this.MemberwiseClone();
}
}
class SoupSpoon : Spoon, ICloneable {
...
public object Clone() {
return this.MemberwiseClone();
}
}
Prototypmönster (JavaScript)
I de klassiska språken som Java, C # eller C ++ börjar vi med att skapa en klass och sedan kan vi skapa nya objekt från klassen eller så kan vi utöka klassen.
I JavaScript skapar vi först ett objekt, sedan kan vi förstärka objektet eller skapa nya objekt från det. Så jag tror, JavaScript visar faktiskt prototyp än det klassiska språket.
Exempel:
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";
}
};
Här skapar vi ett objekt med namnet Customer , och sedan utan att skapa ett nytt objekt utökade vi det befintliga Customer object hjälp av prototypsökord . Denna teknik är känd som prototypmönster .