面向对象的言语必须持有多少个基本特征:

function Parent(firstname)
{
  this.fname=firstname;
  this.age=40;
  this.sayAge=function()
  {
    console.log(this.age);
  }
}
function Child(firstname)
{
  this.saySomeThing=function()
  {
    console.log(this.fname);
    this.sayAge();
  }
  this.getName=function()
  {
    return firstname;
  }
}
var child=new Child("张");
Parent.apply(child,[child.getName()]);
child.saySomeThing();

复制代码 代码如下:

详解JS面向对象编程,js面向对象编制程序

因为JavaScript是基于原型(prototype)的,未有类的定义(ES6有了,那几个如今不谈),我们能接触到的都以指标,真正到位了一切皆为对象

所以大家加以对象就有些模糊了,非常多同学会搞混类型的靶子和对象自己那些定义,大家在接下去的术语中不提指标,大家运用和Java类似的主意,方便了然

方式一

类(函数模拟)

function Person(name,id){
 //实例变量可以被继承
 this.name = name;
 //私有变量无法被继承
 var id = id;
 //私有函数无法被继承
 function speak(){
  alert("person1");
 }
}
//静态变量,无法被继承
Person.age = 18;
//公有函数可以被继承
Person.prototype.say = function(){
 alert("person2");
}

接轨,并调用父类方法

function Person(name,id){
 //实例变量可以被继承
 this.name = name;
 //私有变量无法被继承
 var id = id;
 //私有函数无法被继承
 function speak(){
  alert("person1");
 }
}
//静态变量,无法被继承
Person.age = 18;
//公有静态成员可被继承
Person.prototype.sex = "男";
//公有静态函数可以被继承
Person.prototype.say = function(){
 alert("person2");
}
//创建子类
function Student(){
}
//继承person
Student.prototype = new Person("iwen",1);
//修改因继承导致的constructor变化
Student.prototype.constructor = Student;
var s = new Student();
alert(s.name);//iwen
alert(s instanceof Person);//true
s.say();//person2

接二连三,复写父类方法且落成super()

function Person(name,id){
 //实例变量可以被继承
 this.name = name;
 //私有变量无法被继承
 var id = id;
 //私有函数无法被继承
 function speak(){
  alert("person1");
 }
}
//静态变量,无法被继承
Person.age = 18;
//公有静态成员可被继承
Person.prototype.sex = "男";
//公有静态函数可以被继承
Person.prototype.say = function(){
 alert("person2");
}
//创建子类
function Student(){
}
//继承person
Student.prototype = new Person("iwen",1);
//修改因继承导致的constructor变化
Student.prototype.constructor = Student;
//保存父类的引用
var superPerson = Student.prototype.say;
//复写父类的方法
Student.prototype.say = function(){
 //调用父类的方法
 superPerson.call(this);
 alert("Student");
}
//创建实例测试
var s = new Student();
alert(s instanceof Person);//true
s.say();//person2 student

继承的封装函数

function extend(Child, Parent) {

    var F = function(){};
    F.prototype = Parent.prototype;
    Child.prototype = new F();
    Child.prototype.constructor = Child;
    Child.uber = Parent.prototype;
  }

uber意思是为子对象设一个uber属性,那天本性直接指向父对象的prototype属性。(uber是七个阿拉伯语词,意思是”向上”、”上一层”。)那等于在子对象上开荒一条大路,能够向来调用父对象的方法。这一行放在这里,只是为了促成持续的完备性,纯属备用性质。

方式二

一定于拷贝,通过定义的_this对象来承载想要被持续的对象,那样的话通过传递_this就可以完毕再三再四,比地点那种好理解些

//创建父类
function Person(name,id){
 //创建一个对象来承载父类所有公有东西
 //也就是说_this承载的对象才会被传递给子类
 var _this = {};
 _this.name = name;
 //这样的是不会传递下去的
 this.id = id;
 //承载方法
 _this.say = function(){
  alert("Person");
 }
 //返回_this对象
 return _this;
}
//子类
function Student(){
 //获取person的_this对象,从而模仿继承
 var _this = Person("iwne",1);
 //保存父类的_this引用
 var superPerson = _this.say;
 //复写父类的方法
 _this.say = function(){
  //执行父类的say
  superPerson.call(_this);
  alert("Student");
 }
 return _this;
}
var s = new Student();
s.say();

期待对我们学习javascript程序设计具备辅助。

<script type="text/javascript">
//父类ClassA
function ClassA(sColor) {
  this.color = sColor;
  this.sayColor = function () {
    document.write("Color:" + this.color + "<br/>");
  };
}
//子类ClassB,继承自ClassA
function ClassB(sColor,sName){  
  ClassA.call(this,sColor);//利用call函数,将ClassA的所有方法都赋给ClassB,即实现了继承
  this.name = sName;
  this.sayName = function(){
    document.write("Name:" + this.name + "<br/>");
  }
}
var oClassA = new ClassA("Red");
oClassA.sayColor();
var oClassB = new ClassB("Blue","Jimmy.Yang");
oClassB.sayColor();//这里sayColor方法是从ClassA继承来的
oClassB.sayName();//这是ClassB中的新方法
/*
call函数的演示示例
function sayColor(sPrefix, sSuffix) {
alert(sPrefix + this.color + sSuffix);
};
var obj = new Object();
sayColor.call(obj, "The color is ", ", a very nice color indeed. ");
*/
</script>

可望本文所述对大家JavaScript程序设计具有帮忙。

/*
参谋上边的达成,大家再定义一个矩形:
*/
function Rectangle(iWidth, iHeight){
Polygon.call(this,4);
this.width = iWidth;
this.height = iHeight;
}
Rectangle.prototype = new Polygon();
Rectangle.prototype.getAreas = function(){
return this.width * this.height;
}
/*
好了,上边大家定义了几个基类和三个子数,下面大家来测验一个那七个子类是或不是能健康干活:
*/
var t = new Triangle(3,6);
var r = new Rectangle(4,5);
alert(t.getAreas()); //输出9表达准确
alert(r.getAreas()); //输出20认证准确
</script>

您恐怕感兴趣的篇章:

  • JAVASC福特ExplorerIPT THIS详解 面向对象
  • JS 拼图游戏 面向对象,注释完整。
  • javascript 面向对象编制程序基础 多态
  • javascript 面向对象斩新理练之数据的包裹
  • JavaScript 面向对象之命名空间
  • JS面向对象编制程序之对象使用深入分析
  • Javascript 面向对象(一)(共有方法,私有方法,特权方法)
  • JS左右无缝滚动(一般方法+面向对象方法)
  • javascript面向对象入门基础详细介绍

因为JavaScript是依据原型(prototype)的,未有类的概念(ES6有了,这些临时不谈),我们能接触到的都…

期望本文所述对大家JavaScript程序设计具有支持。

function Parent()
{
  this.sayAge=function()
  {
    console.log(this.age);
  }
}
function Child(firstname)
{
  this.fname=firstname;
  this.age=40;
  this.saySomeThing=function()
  {
    console.log(this.fname);
    this.sayAge();
  }
}
Child.prototype=new Parent();
var child=new Child("张");
child.saySomeThing();

<script>
//定义js的user对象
function User(name,age){
this.name=name,
this.age=age,
this.getName=function(){
return this.name;
},
this.getAge=function(){
return this.age;
}
}
//实例化一个对象
var use=new User(“aa”,21);
alert(use.name);
alert(use.getAge());
//js对象承接
/*
jb51.net
在面向对象的编制程序方法中,对象继承是至关重要的,那么怎么在javascript中落到实处持续机制吗。由于javascript并非三个冷酷的面向对象的语言,因而在对象承继上也显的不均等。大家也来成立多个基类Polygon,代表贰个五头形,三个多头形有个联合的性质正是边数(sides)和一个联手的法子总括面积(getAreas)。那样我们的那具Polygon类看起来就好像上面那样定义:
*/
function Polygon(iSides){
this.sides = iSides;
}
Polygon.prototype.getAreas = function(){
return 0;
}
/*
因为基类并不可能分明面积,因而在此地大家回来为0。
紧接着我们就创造多个子类Triangle,叁个三角,明显这么些三角是要从三头形承继的,由此大家要让那一个Triangle类承袭Polygon类,而且要覆盖Polygon类的getAreas方法来回到三角形的面积。大家来看下在javascript中的达成:
*/
function Triangle(iBase, iHeight){
Polygon.call(this,3);
//在那边我们用Polygon.call()来调用Polygon的构造函数,并将3当作参数,表示那是三个三角,因为边是规定的,所以在子类的构造函数中就无需钦点边了
this.base = iBase; //三角形的底
this.height = iHeight; //三角形的高
}
Triangle.prototype = new Polygon();
Triangle.prototype.getAreas = function(){
return 0.5 * this.base *this.height;
//覆盖基类的getAreas方法,重回三角形的面积
}

正文汇报了Javascript轻便完毕面向对象编制程序承袭实例代码。分享给我们供大家参谋,具体如下:

落实原理:让父类的构造函数成为子类的艺术,然后调用该子类的艺术,通过this关键字给具备的天性和措施赋值

您恐怕感兴趣的小说:

  • javascript的函数、创制对象、封装、属性和措施、承袭
  • JavaScript面向对象之Prototypes和后续
  • javascript
    面向对象,完毕namespace,class,承接,重载
  • Javascript基于对象三大特点(封装性、承继性、多态性)
  • Javascript面向对象编制程序(二)
    构造函数的承继
  • javascript
    面向对象斩新理练之原型继承
  • Javascript面向对象编制程序(三)
    非构造函数的存在延续
  • javascript
    面向对象编制程序基础:承接
  • javascript
    面向对象斩新理练之继续与多态
  • 前端开采必须明白的JS之原型和继续
  • JS承继–原型链承袭和类式承接
  • JavaScript的原型承袭详解
  • JavaScript使用原型和原型链落成目的承袭的格局详解

那八个着力属性,javascript都得以支撑,所以javascript确实是一种弱类型的面向对象的言语,这里给出几个归纳的类承接的代码

落到实处原理:改变函数内部的函数上下文this,使它指向传入函数的切切实实目标

admin

相关文章

发表评论

电子邮件地址不会被公开。 必填项已用*标注