好吧,所以我要做的是做一个弹丸类,然后在Java中以一种方式进行基础知识类"扩展"弹丸。
我想设置父级的vars,并在子类中设置任何新的vars。
var Projectile = function(x, y){
this.x = x;
this.y = y;
}
Projectile.prototype.update(){
console.log("should not be called");
}
Projectile.prototype.checkIfWallHit(){
console.log("should be called");
}
,然后是孩子课。
var BasicShot = new function(x, y, left){
this = new Projectile(x,y);
this.left = left;
}
BasicShot.prototype.update(){
console.log("should be called");
}
但是,当我尝试这样做时,当我尝试制作基础知识对象时,它说"基本次数未定义"。
那么,如何扩展弹丸类?
这是基本模式,请参阅注释:
// === Projectile
// The constructor
function Projectile(x, y) {
// Do things to initialize instances...
this.x = x;
this.y = y;
}
// Add some methods to its prototype
Projectile.prototype.update = function() {
// This is a method on `Projectile`
snippet.log("Projectile#update");
};
Projectile.prototype.checkIfWallHit = function(){
snippet.log("Projectile#checkIfWallHit");
};
// ==== BasicShot
// The constructor
function BasicShot(x, y, left) {
// Give Projectile a chance to do its thing
Projectile.call(this, x, y);
this.left = left;
}
// Hook it up to `Projectile`
BasicShot.prototype = Object.create(Projectile.prototype);
BasicShot.prototype.constructor = BasicShot; // JavaScript does this by default, so let's maintain it when replacing the object
// Add methods to its prototype
BasicShot.prototype.update = function() {
snippet.log("BasicShot#update");
};
// === Usage
snippet.log("Using Projectile");
var p = new Projectile(1, 2);
p.update(); // Projectile#update
p.checkIfWallHit(); // Projectile#checkIfWallHit
snippet.log("Using BasicShot");
var c = new BasicShot(1, 2, 3);
c.update(); // BasicShot#update
p.checkIfWallHit(); // Projectile#checkIfWallHit
<!-- Script provides the `snippet` object, see http://meta.stackexchange.com/a/242144/134069 -->
<script src="http://tjcrowder.github.io/simple-snippets-console/snippet.js"></script>
在ES6(下一个版本的JavaScript)时,将获得 lot 更简单:
// REQUIRES ES6!!
class Projectile {
constructor(x, y) {
this.x = x;
this.y = y;
}
update() {
snippet.log("Projectile#update");
}
checkIfWallHit() {
snippet.log("Projectile#checkIfWallHit");
}
};
class BasicShot extends Projectile {
constructor(x, y, left) {
super(x, y);
this.left = left;
}
update() {
snippet.log("BasicShot#update");
}
}
它与上面的第一个示例做的事情相同,新的语法只是句法糖。但这真的是很好的糖。
获得这种继承的最佳方法是使用典型的继承。
一种一般实践是将全局函数与对象相关联并使用它来创建派生对象。(由于全球很糟糕,因此有一些方法可以规避这一点)。
Object.prototype.begetObject = function () {
function F() {}
F.prototype = this;
return new F();
};
BasicShot= Projectile.begetObject();
您可以像您在问题中提出的方式相同的方式覆盖/扩展功能。
BasicShot.prototype.update = function (){
console.log("should be called");
};
我强烈建议您浏览有关原型继承的精美文章,这绝对值得。http://javascript.crockford.com/prototypal.html
您可以做这个
http://jsfiddle.net/jigardafda/0qkevb0q/2/
var factory = {};
factory.getProjectileObject = function(xarg, yarg){
var Projectile = function(x, y){
this.x = x;
this.y = y;
}
Projectile.prototype.update = function() {
console.log("should not be called");
}
Projectile.prototype.checkIfWallHit = function() {
console.log("should be called");
}
return new Projectile(xarg, yarg);
}
factory.getBasicshotObject = function(xarg, yarg, leftarg) {
var BasicShot = function(left){
this.left = left;
}
// Extending parents methods
BasicShot.prototype = factory.getProjectileObject(xarg, yarg);
BasicShot.prototype.constructor = BasicShot;
BasicShot.prototype.update = function(){
console.log("should be called");
}
return new BasicShot(leftarg);
}
i = factory.getBasicshotObject(12,34, 23);
console.log(i);