js的面向对象的三大特征
简述对面向对象的三大特征的理解
简述对面向对象的三大特征的理解
面向对象有三大特点：封装、继承、多态。
1、继承性：
继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。
对象的一个新类可以从现有的类中派生，这个过程称为类继承。
新类继承了原始类的特性，新类称为原始类的派生类（子类），而原始类称为新类的基类（父类）。
派生类可以从它的基类那里继承方法和实例变量，并且类可以修改或增加新的方法使之更适合特殊的需要。
2、封装性：
封装是把过程和数据包围起来，对数据的访问只能通过已定义的界面。
面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访问其他对象。
3、多态性：
多态性是指允许不同类的对象对同一消息作出响应。
多态性包括参数化多态性和包含多态性。
多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。
面向对象的三大特性(封装-继承-多态)
一丶封装1 权限修饰符可以用来修饰成员变量和成员方法，对于类的权限修饰只可以用public和缺省default。
被public修饰的类可以在任意地方被访问；default类只可以被同一个包内部的类访问。
权限由大到小：public protected default(不写) private被private修饰的成员只能在本类中访问，外界不能访问2 set()/get()方法（1）this关键字a.可以用来调用变量，方法，构造方法；b.this.xx 理解为调用当前类的xx。
（2）成员变量和局部变量1）在类中的位置不同a:成员变量:在类中,方法外b:局部变量:在方法声明上（形式参数）,或者是在方法定义中2）在内存中的位置不同a:成员变量:在堆内存b:局部变量:在栈内存3）生命周期不同a:成员变量:随着对象的创建而存在,随着对象的消失而消失b:局部变量:随着方法调用而存在,随着方法的调用结束而消失4）初始化值不同a:成员变量:有默认值b:局部变量:必须初始化值,否则报错!(在使用它之前,没有初始化) （3）set()/get()方法当成员变量被private修饰时，不在本类中无法直接访问，便需要set()/get()方法来解决这个问题3 封装性封装：是面向对象的第一大特性，所谓封装，就是值对外部不可见（一般而言被private修饰），外部只能通过对象提供的接口（如set()/get()方法）来访问。
封装的好处：a.良好的封装能够减少耦合；b.类内部的结构可以自己修改，对外部影响不大；c.可以对成员进行更精准的控制（防止出现与事实不符的情况）；d.影藏实现细节。
注意：在开发中，类的成员变量全部要进行封装，封装之后通过set()/get()方法访问。
二丶继承extends1 实现：通过 class Zi extends Fu{} 实现类的继承（1）子类继承父类，父类中声明的属性，方法，子类都可以获取到；当父类中有私有的属性方法时，子类同样可以获取到，由于封装性的设计，使得子类不能直接调用访问。
面向对象设计的三个基本特征
⾯向对象设计的三个基本特征
1.抽象与封装:
抽象是把系统中需要处理的数据和在这些数据上的操作结合在⼀起，根据功能、性质和⽤途等因素抽象成不同的抽象数据类型。
每个抽象数据类型既包含了数据，⼜包含了针对这些数据的授权操作。
在⾯向对象的程序设计中，抽象数据类型是⽤“类”这种结构来实现的，每个类⾥都封装了相关的数据和操作。
封装是指利⽤抽象数据类型和基于数据的操作结合在⼀起，数据被保护在抽象数据类型的内部，系统的其他部分只有通过包裹在数据之外被授权的操作，才能与这个抽象数据类型进⾏交互。
2. 继承：
它是与传统⽅法不同的⼀个最有特⾊的⽅法。
它是⾯向对象的程序中两个类之间的⼀种关系，即⼀个类可以从另⼀个类（即它的⽗类）继承状态和⾏为。
继承⽗类的类称为⼦类。
继承的优越性：通过使⽤继承，程序员可以在不同的⼦类中多次重新使⽤⽗类中的代码，使程序结构清晰，易于维护和修改，⽽⼦类⼜可以提供⼀些特殊的⾏为，这些特殊的⾏为在⽗类中是没有的 。
3.多态：
是指⼀个程序中同名的⽅法共存的情况，调⽤者只需使⽤同⼀个⽅法名，系统会根据不同情况，调⽤相应的不同⽅法，从⽽实现不同的功能。
多态性⼜被称为“⼀个名字，多个⽅法”。
面向对象的三大特征
⾯向对象的三⼤特征
⾯向对象有三个特征：1.封装，2.继承，3.多态。
封装
⼀个不可分割的独⽴实体；
隐藏内部细节；
保留对外接⼝。
封装的好处：
1. 保证数据的安全性；
2. 提供清晰的对外接⼝；
3. 类内部实现可任意修改，不影响其他类。
继承
继承可以使⼦类具有⽗类的属性和⽅法，或者重新定义、追加属性和⽅法等。
对象的继承代表了⼀种‘is-a’的关系，如果两个对象A和B，可以描述为‘B是A’，则表明B可以继承A；例如⼈是动物，猫是动物，狗是动物等等......
实际上，继承者还可以理解为是对被继承者的特殊化，因为它除了具备被继承者的特性外，还具备⾃⼰独有的个性。
例如猫块可以爬树，⽽并不是所有动物都会爬树。
这也就说明量对象之间是不能颠倒顺序的。
继承定义了类如何相互联系，共享特性，继承的⼯作⽅式是，定义⽗类和⼦类，或叫做基类和派⽣类，其中⼦类继承⽗类的所有特性，⼦类不仅继承了⽗类的所有特性，还可以定义新的特性。
继承提⾼了代码复⽤性
多态
同⼀操作作⽤于不同的对象，可以有不同的解释，产⽣不同的执⾏结果，这就是多态性
简单来说就是⼀类事物有多种形态，例如动物有多态：猫、狗、⼈...
多态的特点：
1. 多态前提是必须有继承；
2. ⽗类引⽤变量指向⼦类；
3. ⽗类引⽤变量调⽤⽅法时，会调⽤⼦类重写后的⽅法。
JavaScript 的面向对象特性
JavaScript的面向对象特性分析面向对象编程思想的本质面向对象编程思想的本质体现在——面向对象编程语言必须包含这些特性：对象、属性（变量）、行为（方法）、类、封装、继承、多态等。
面向对象编程思想的重点在“对象”上，对象实质上是“客观事物”在程序设计语言中的表现形式，客观事物可以是某个客观存在的人或物，或者某些抽象的概念。
事物的静态特征称之为属性，而事物的动态行为或动作称之为方法。
将具有相同属性和行为的一组对象的集合抽象成为类的概念，可以基于同一个类实例化许多不同的对象，类是模板，而对象是在这些模板的基础上被创建出来的实体。
封装的本质是为了实现信息的隐藏，就是把对象的属性和行为结合成一个独立的整体，这样做可以将对象的设计与使用分开，使用对象时不用去关心其内部的信息，只需通过传递消息来访问对象。
继承是指在已经存在的类的基础上，构造出新的类，它很好地实现了代码复用。
多态是指不同对象通过调用名字相同的方法来实现各自行为的能力，这符合现实生活的习惯和要求，而且可以使程序更加简洁和一致。
面向对象是一种不依赖于某种语言而存在的编程思想。
Java通过关键词class和extends很好地实现了面向对象编程，但并不是说这一思想只能通过这种方式来实现，一门编程语言可以借助其自身特点通过合适的某种方式来实现面向对象编程思想。
所以，不能先入为主地认为基于类来实现面向对象的语言才是面向对象语言，而像JavaScript这样基于原型对象来实现面向对象的则不是面向对象语言。
实际上，JavaScript虽然没有类的概念，没有class和extends关键词，但通过原型对象，它也实现了对象创建、封装、继承、多态等面向对象的特性。
下面就来讨论基于类的面向对象和JavaScript基于原型对象的面向对象的差别。
JavaScript与传统基于类的面向对象的比较分析在基于类的面向对象方式中，通过类来创建多个同属性和行为的对象。
而ECMAScirpt中没有类的概念，其中的对象与基于类的语言中的对象有所不同，ECMA-262将对象定义为：“无序属性的集合，其属性可以包含基本值、对象或者函数”。
简述面向对象程序设计的三大基本特点
简述面向对象程序设计的三大基本特点面向对象程序设计（Object-Oriented Programming，简称OOP）是一种常用的编程范式，它具有三大基本特点：封装、继承和多态。
封装是面向对象程序设计的第一个基本特点。
它指的是将数据和对数据的操作封装在一个类中，通过类的接口来隐藏数据的实现细节。
封装使得数据和操作数据的方法被组织在一个单独的逻辑单元中，提高了代码的可维护性和可重用性。
通过封装，我们可以将数据和相关的操作绑定在一起，形成一个独立的实体，从而实现了数据的保护和安全性。
对外部用户来说，只需要通过类的公共接口来访问数据和操作，不需要关心内部的具体实现细节。
这种封装的特性可以有效地隐藏对象的内部信息，提高了代码的可读性和可理解性。
继承是面向对象程序设计的第二个基本特点。
继承是指一个类（称为子类或派生类）可以继承另一个类（称为父类或基类）的属性和方法。
通过继承，子类可以拥有父类的属性和方法，同时可以在此基础上进行扩展和定制。
继承可以有效地实现代码的重用，避免了重复编写相同的代码。
另外，继承还可以建立类之间的层次关系，使得代码的组织结构更加清晰和直观。
继承的特性使得面向对象程序设计具有了更强的灵活性，可以在不破坏原有代码的基础上进行功能扩展和修改。
多态是面向对象程序设计的第三个基本特点。
多态是指同一个方法在不同的对象上可以有不同的行为。
具体来说，是通过父类的引用指向子类的对象，以实现同一个方法在不同对象上表现出不同的行为。
多态可以提高代码的灵活性和可拓展性，使得程序更加易于扩展和维护。
通过多态，可以处理同一类对象的不同实现方式，提高了代码的可读性和可维护性。
多态还可以实现接口的统一，使得不同的对象可以以相同的方式调用方法。
面向对象程序设计的三大基本特点相互依赖、相互联系，共同构成了面向对象编程的核心思想和基本原则。
封装保护了对象的内部数据和操作，提供了对外的公共接口；继承实现了代码的重用和扩展，建立了类之间的层次关系；多态实现了同一方法在不同对象上的不同行为，提高了代码的灵活性和可拓展性。
简述面向对象三大特征的理解
简述面向对象三大特征的理解
面向对象三大特征的理解：
1、封装：封装是指将实现细节与外部接口分离开来，使外部程序只能通过接口对内部实现不可见，以达到安全隐蔽内部实现，使得调用者不必担心内部实现之细节而单纯地调用，也就是说在使用某个对象时，不需要知道其内部具体实现的细节，只要知道对象具备的功能即可。
2、继承：继承是指多个对象可以从公共父类中继承数据属性和行为，子类之间还可以相互继承，这种继承关系能够让类之间的体系结构更加清晰，减少编码量，提高代码的复用性，使得程序结构更加清晰和有条理。
3、多态：多态是指不同的对象之间可以进行不同操作，也就是说多态是指在同一个消息被传递到不同的对象时，可以采取不同的行为，而且多态的行为可以在运行时动态变化，从而实现更加灵活的程序设计。
- 1 -。
javascript的面向对象的特征
所有的函数都具有这两个方法，它们在使用上没有太大差别， 主要区别就在于传入参数不同：
call使用可变参数序列进行值传递，而apply则使用数组或者 arguments对象进行传递。 call方法的语法： call([thisObj[,arg1[, arg2[, [,.argN]]]]]) 参数 thisObj 可选项。将被用作当前对象的对象。 arg1, arg2, , argN 可选项。将被传递方法参数序列。 说明 call 方法可以用来代替另一个对象调用一个方法。call 方法可 将一个函数的对象上下文从初始的上下文改变为由 thisObj 指 定的新对象。
Javascript的面向对象特征
Javascript中的对象
在 JavaScript 中，对象分为两种。一种可以称为“普通对象”，就 是我们所普遍理解的那些：数字、日期、用户自定义的对象（如：{}） 等等。
还有一种，称为“方法对象”，就是我们通常定义的 function。你 可能觉得奇怪：方法就是方法，怎么成了对象了？但是在 JavaScript 中，方法的确是被当成对象来处理的。 下面是一个简单的例子：
//定义一个函数func1，具有属性p和方法A
function func1(){ this.p="func1-"; this.A=function(arg){ alert(this.p+arg); } }
//定义一个函数func2，具有属性p和方法B function func2(){ this.p="func2-"; this.B=function(arg){ alert(this.p+arg); } }
面向对象编程三大特性
⾯向对象编程三⼤特性⾯向对象：以对象为中⼼的编程思想，通过指挥对象实现具体功能。
⾯对过程：以过程为中⼼的编程思想，实现具体功能都是⾃⼰实现。
类和对象的关系：类：类是对现实⽣活类中具有共同属性和⾏为的实物的抽象。
类是对象的数据类型，类是具有相同属性和⾏为的⼀组对象的集合。
类就是对现实事务的⼀种描述。
⽽对象则是以类为模板所创建的。
类的组成*属性：指事物的特征，也就是成员变量。
*⾏为：指事物能执⾏的操作，也就是成员⽅法。
*构造⽅法：⽅法名与类名⼀致，没有返回值类型，没有返回值。
⽤于创建对象，没创建⼀次对象，执⾏⼀次构造⽅法，不能⼿动调⽤构造⽅法。
系统默认为⽆参构造，如果定义了构造⽅法，⽆参构造不存在。
对象创建内存模型（1）当程序开始运⾏，⽅法区以加载好程序所需类的字节码⽂件。
（2）栈内存加载程序，当运⾏到需要创建对象时，会在堆内存中创建对象，此时对象的成员变量为初始值，成员⽅法为地址，指向⽅法区中的类成员⽅法。
（3）堆内存中所创建的对象指向栈内存中引⽤，然后赋值。
可以通过对象引⽤找到堆内存中的成员变量进⾏赋值，使⽤成员⽅法则是通过引⽤找到堆内存中的成员⽅法地址，然后在⽅法区中找到具体的成员⽅法。
成员变量和局部变量的区别：（1）位置不同：成员变量在⽅法外，局部变量在⽅法内部或⽅法声明上（2）内存位置不同：成员变量在堆内存中，局部变量在栈内存中（3）声明周期不同：成员变量随对象的存在⽽存在，局部变量随⽅法的调⽤⽽存在，⽅法调⽤结束就消失（4）初始化值不同：成员变量默认初始化值，局部变量没有默认初始值，必须⾃定义初始化赋值才能使⽤。
⾯向对象三⼤特性之⼀———封装将成员变量隐藏在对象内部，外界⽆法直接操作，通过该类提供的⽅法来实现对隐藏信息的操作和访问，封装通过get、set⽅法的⽅式来控制成员变量的操作，提⾼了代码的安全性和复⽤性。
封装的思想实现类⾼内聚、低耦合this关键字this修饰的变量⽤于代指成员变量，其主要作⽤是区分成员变量和局部变量的重名问题。
JavaScript进阶学习2
JS面向对象
JS面向对象
四、 封装
3、在类的外部通过.语法添加 我们还可以在类的外部通过. 语法进行添加，因为在实例化对象的时候，并不会执行到在类外部通过. 语法 添加的属性，所以实例化之后的对象是不能访问到. 语法所添加的对象和属性的，只能通过该类访问
JS面向对象
四、对象的继承
继承：子类可以使用父类的所有功能，并且可以对这些功能进行扩展。继承的过程，就是从一般到特殊的 过程。
单例模式是一种常用的模式，有一些对象我们往往只需要一个，比如全局缓存、浏览器的window对象。在 js开发中，单例模式的用途同样非常广泛。试想一下，当我们单击登录按钮的时候，页面中会出现一个登录 框，而这个浮窗是唯一的，无论单击多少次登录按钮，这个浮窗只会被创建一次。因此这个登录浮窗就适 合用单例模式。 总结一下它的使用场景：
如果替换了prototype 对象，那么下一步必然是为新的prototype对象加上constructor属性，并将这个 constructor属性指回原来的构造函数
JS面向对象
JS面向对象
V
2 JS设计模式
JS设计模式
一、单例模式
在传统开发工程师眼里，单例就是保证一个类只有一个实例，实现的方法一般是先判断实例存在与否，如 果存在直接返回，如果不存在就创建了再返回，这就确保了一个类只有一个实例对象。在JavaScript里，单 例作为一个命名空间提供者，从全局命名空间里提供一个唯一的访问点来访问该对象。
javascript--对象的特性
//Object.prototype.__proto__ //3.Obj.call(obj) 改变this指针方向 //4.return obj; 创建对象完成
5.继承顺序
参考：/wangyingblog/p/5583825.html
/article/article1/10201.html?id=1092
} } people.prototype.done=function () {
console.log("原型上的属性") } //子类 function stu() {
this.age=10; } //原型继承 //核心：子类在原型上继承父类的实例
stu.prototype=new people() //先继承再调用 var obj=new stu("继承") obj.say() obj.done()//可继承父类原型上的属性与方法
2.ES6继承
class fun{ constructor(){ ="zhangsan" } done(){ console.log() }
} class stu extends fun{//extends 实现继承
constructor(){ super(); //将父类的this继承到子级中
//检测某个构造函数是否为对象的实例化，实质上是看对象是否在构造函数的原型链上
3.原型prototype
在js中每定义一个对象（函数），对象中都会包含一些预定义的属性，其中函数对象的一个属性就是原型对象 prototype。注：普通 对象没有prototype,但有__proto__属性。在js继承规则中，实例化出来的对象能够继承构造函数Prototype属性身上的属性与方法。
面向对象的三大特征
接下来，通过一个案例来演示子类如何继承多个父类,如例12-14所示：
12.6 面向对象的三大特征
12.6.2 继承
# file GENERATED by distutils, do NOT edit # 定义表示鱼的类 class Fish(object):
简尔言之，把隐藏属性、方法与方法实现细节的过程统称为封装。为了保护类里面的 属性，避免外界任意赋值，可以采用以下方式实现：
在属性名的前面加上 “__”(两个下划线)，定义属性为私有属性； 通过在类的里面定义两个方法供外界调用，实现属性值的设置及获取。
12.6 面向对象的三大特征
12.6.1 封装（隐藏数据和保护属性）
# 定义用于跑的方法 def call(self):
print("---旺旺旺---") # 定义一个狗的子类斑点狗 class PersianDog(Dog):
Pass dog = PersianDog("雪白色") dog.call() print(dog.color)
例12-12 单继承
12.6 面向对象的三大特征
继承：即一个派生类（derived class）继承基类（base class）的属性和方法。 简单点来说，它们之间的关系是：派生类是由基类派生出来的，基类就是派生类的子类， 而派生类就是基类的父类。
接下来，为了让大家更好地学习继承，我们将从三个方面：单继承、多继承及重写来 学习。
12.6 面向对象的三大特征
例12-13 继承的注意事项
12.6 面向对象的三大特征
12.6.2 继承
在例12-13中，先是定义一个父类Father,它有一个私有属性__color、私有方法 __show()和公有方法show()，接着定义了一个子类Son。子类son中拥有一个方法 sonVisit（），该方法分别需要访问父类的私有属性__color、私有方法__show()和公 有方法show()。
js真正了解面向对象
js的几种数据类型：number,string,boolean,object,undefined 五种数据类型js的常见内置对象类：Date,Array,Math、Number、Boolean、String、Array、RegExp、Function、Object。
js的两个类型判断方法：typeof、instanceoftypeof:一元运算算。
eg:typeof 1 将返回number.它返回的是顶级的几种数据类型instanceof：二元运算符eg: myObj instanceOf MyObj 返回的是一个boolean值。
应用数据类型包括自己定义的类。
判断变量是不是此类的实例它和typeof都只能应用于js内置及自定义的数据类型，不包括DOM对像，例如window,document.我们平台声明的数据类型也就是number,string,boolean,object undefined及其object的子类型。
声明的类型也就拥有所属类型的本性方法常用的有string类型的substring,indexOf,length方法。
主要的是要掌握function 定义出的类型。
我们利用function 可以声明一个函数，也可以做为创建类的关键字。
当作为函数关键词使用时，没有什么好说的。
但是当做为创建类的关键词时，我们需要知道js的一些特征东西。
（使用function做为函数关键词还是类关键词，因自己的目的而定）。
当我们使用函数关键词时js面向对象的特征基本用不到，所以就不多说了。
现在就说一下function做为类关键词，我们需要常用的一些js特征，以适应我们的面向对象的三大特性：封装、继承、多态封装性：类型于其它的面向对象语言一样，用大括号来限定变量的作用域。
这样就有了局部变量。
如果声明在最外面，那就是全局变量。
那么现在还少的是什么？就是成员变量。
幸好js支持闭包特性，例如：function Person(){var name="张三";var sex ="男";return {"getName":function(){return name;},"getSex":function(){return sex;},"setName":function(_name){name=_name;},"setSex":function(_sex){sex = _sex;},"aliasName":name;};}var person = new Person();alert();//undefinedalert(person.getName());//张三person.setName("李国");alert(person.getName());//李国这样就有了私有成员变量。
js第五章_面向对象编程2
从 prototype引出对构造函 数模式创建对象的思考
☞ 类名.prototype.函数名=function() {} 这个也称为后置绑定.
能不能给所有对象绑定一个 属性值?
l JS面向(基于)对象编程—三大特征
■ 封装—prototype的思考(摘选 阮一峰 网络文章 )
4. 构造函数模式的问题 构造函数方法很好用，但是存在一个浪费内存的问题。 请看，我们现在为Cat对象添加一个不变的属性"type"（种类），再添加一个方法eat（吃老鼠）。那么，原型对象Cat就变成了下面这样：
类名.call(对象名,参数,..) 类名.apply(对象名,[参数1,...])
//Stu.call(this,name,age); Stu.apply(this,[name,age]); this.payFee=function(sal){ window.alert("应付学费1="+sal*0.5); }} var pupil1=new Pupil("xm1",12); pupil1.show(); pupil1.payFee(1000); var midStu1=new MidStu("xh4",22); midStu1.show(); midStu1.payFee(1000); window.alert("********"); pupil1.show();
面向对象3大特性
⾯向对象3⼤特性1.⾯向对象的三⼤特点：封装、继承、多态。
2.字段：存储数据，访问修饰符设置为privae;属性：保护字段。
对字段的取值和赋值进⾏限定。
调⽤构造函数对每个属性赋值的过程称为对象初始化。
new 关键字：1.在堆中开辟内存空间，2.在开辟的内存空间中创建对象、3，调⽤对象的构造函数初始化对象。
字段保护的三种⽅法：1.通过属性中的get；set设置；在构造函数中先判断在给属性赋值来实现保护作⽤。
return的作⽤：1.⽴即结束本⽅法；2.在⽅法中返回要返回的值。
this的作⽤:1.代表当前对象2.在类中显⽰的调⽤构造函数。
继承：继承解决了代码冗余，实现多态，增强了代码的扩展性，便于维护。
继承的特点：1.单根性2.传递性⼦类中并没有继承⽗类的构造函数，⼦类在创建对象时，在⼦类对象中创建了⽗类的对象，故需要调⽤⽗类的构造函数来初始化对象，若⽗类中声明了有参数的构造函数，则⼦类创建对象时，不能创建成功，因为在创建过程中，不能调到⽗类中⽆参数的构造函数；解决办法：1.在⽗类中显⽰的声明⽆参数的构造函数。
2.在⼦类中调⽤⽗类的构造函数，是⽤base（）关键字。
如果⼀个⼦类继承了⼀个⽗类，那么这个⼦类除了可以使⽤⾃⼰的成员外，还可以使⽤从⽗类那⾥继承过来的成员，但是⽗类永远都只能使⽤⾃⼰的成员，⽽不能使⽤⼦类的成员，⼦类之间也不能相互使⽤对⽅的成员。
⾥⽒转换：1.⼦类可以赋值给⽗类2.⽗类中包含⼦类，则⽗类可以强制转换成⼦类。
bool b = A is B .若A能转换成B,则b= true;否则b = false;B b = A as B 若A能转换成B ，则返回B类型，否则转换不成功。
多态：实现多态的三种⽅法：1.虚⽅法如果⽗类知道如何实现，并且⽅法知道如何写。
此时⽤虚⽅法可以实现多态。
2.抽象类如果⽗类不知道如何实现，且⽅法不知道怎么写，则⽤抽象类来实现。
3.接⼝。
js面向对象及面向对象的三大特性
js⾯向对象及⾯向对象的三⼤特性⼀：js⾯向对象编程在es5中我们是这样去写⾯向对象的编程⽅式的：function Person(name) {//构造函数⾥⾯的⽅法和属性this._name = name;this.getName = function () {console.log(this._name);};this.setName = function (name) {this._name = name;};}let p = new Person("张三");p.getName(); // 张三p.setName("李四");p.getName(); // 李四在es6中，提供了新的⽅式去书写⾯向对象编程，这种⽅式更加接近⾯向对象的书写⽅式，但本⾝只是⼀种语法糖：// 定义类class Person {//类的构造函数，实例化的时候执⾏，new的时候执⾏constructor(name) {this._name = name;}getName() {console.log(this._name);}setName(name) {this._name = name}}let p = new Preson('张三')p.getName(); // 张三p.setName('李四');p.getName(); // 李四⼆：⾯向对象的三⼤特征三⼤特征分别为：封装，继承和多态1：封装我们平时所⽤的⽅法和类都是⼀种封装，当我们在项⽬开发中，遇到⼀段功能的代码在好多地⽅重复使⽤的时候，我们可以把他单独封装成⼀个功能的⽅法，这样在我们需要使⽤的地⽅直接调⽤就可以了。
2：继承继承在我们的项⽬开发中主要使⽤为⼦类继承⽗类，下⾯是es6继承的书写⽅法class Father { constructor(name) {this._name = name;} //实例⽅法，通过实例对象调⽤getName() {console.log(this._name);} // 静态⽅法不会被继承,并且是通过类名去调⽤的 static hitXiaoMing() {console.log("打⼩明")}}class Son extends Father {constructor(name, age) {//实例化⼦类的时候把⼦类的数据传给⽗类（这⾥的super必须有，super⾥的参数是所继承的⽗类实例化所需要的数据）super(name);this._age = age;} }var DaMing = new Father('⼤明');Father.hitXiaoMing(); //打⼩明DaMing.getName(); //⼤明var XiaoMing = new Son('⼩明'，15);XiaoMing.getName(); //⼩明特别提醒：继承会继承⽗类的实例属性和实例⽅法，并不会继承静态属性和静态⽅法，并且静态⽅法只能通过类名去调⽤。
JS中对象的特征：封装（函数）
JS中对象的特征：封装（函数）⾯向对象的特征1、第⼀个特征：封装1.1概念：隐藏实现细节的过程1.2优点：重⽤和隐藏细节Java⾥⾯有权限修饰符，但是JS⾥⾯没有，JS所有的属性都是公共的，为了让属性私有化，就有相应⽅法：第⼀种：定义⼀个私有变量，结合get/set函数function Student(name,age,phone){ = name;//公共属性this.age = age;//公共属性let _phone = phone;//私有属性this.setPhone = function(phone){console.log("1");_phone = phone;//设置私有属性}this.getPhone = function(){console.log("2");return _phone;//获取私有属性}}let s1 = new Student("关⽻",19,322);s1.setPhone(123);//修改私有属性，因为调⽤了setPhone函数此时会输出1console.log(,s1.age,s1.getPhone());//因为调⽤了getPhone函数，会先输出2，再输出关⽻ 19 123第⼆种 defineProperty⽅法function Teacher(name,age,hoby){ = name;this.age = age;this.hoby = hoby;}Object.defineProperty(Teacher.prototype,"name",{set:function(name){_name = name;},get:function(){if (this.age > 30) {return "⼤龄" + _name;}return _name;}})let T1 = new Teacher("张飞",32,"游泳");console.log(,T1.age,T1.hoby);//输出⼤龄张飞 32 游泳。
Javascript基于对象三大特性（封装性、继承性、多态性）
Javascript基于对象三⼤特性（封装性、继承性、多态性）Javascript基于对象的三⼤特征和C++，Java⾯向对象的三⼤特征⼀样，都是封装(encapsulation)、继承(inheritance )和多态(polymorphism )。
只不过实现的⽅式不同，其基本概念是差不多的。
其实除三⼤特征之外，还有⼀个常见的特征叫做抽象(abstract)，这也就是我们在⼀些书上有时候会看到⾯向对象四⼤特征的原因了。
⼀、封装性封装就是把抽象出来的数据和对数据的操作封装在⼀起，数据被保护在内部，程序的其它部分只有通过被授权的操作(成员⽅法)，才能对数据进⾏操作。
案例：<html><head><script type="text/javascript">function Person(name, agei, sal){// 公开 = name;// 私有var age = agei;var salary = sal;}var p1 = new Person('zs', 20, 10000);window.alert( + p1.age);</script></head><body></body></html>PS：JS封装只有两种状态，⼀种是公开的，⼀种是私有的。
通过构造函数添加成员⽅法和通过原型法添加成员⽅法的区别1、通过原型法分配的函数是所有对象共享的.2、通过原型法分配的属性是独⽴.(如果你不修改属性，他们是共享)3、建议，如果我们希望所有的对象使⽤同⼀⼀个函数，最好使⽤原型法添加函数，这样⽐较节省内存.案例：function Person(){="zs";var age=20;this.abc=function(){window.alert("abc");}function abc2(){window.alert("abc");}}Person.prototype.fun1=function(){window.alert();//ok//window.alert(age);//no ok//abc2();//no okthis.abc();//ok}var p1=new Person();p1.fun1();特别强调：我们前⾯学习的通过prototype给所有的对象添加⽅法，但是这种⽅式不能去访问类的私有变量和⽅法。
面向对象的三大特性介绍
⾯向对象的三⼤特性介绍⾯向对象编程三⼤特性介绍上⼀节中我们讲了⾯向对象的⼀些基础知识，这⼀节我们继续加深⾯向对象编程的知识，让⼤家更深层次的了解⾯向对象编程⾸先讲讲⾯向对象的三⼤特性：封装、继承、多态⼀、封装：封装：将内容封装到某个地⽅，之后调⽤的时候直接调⽤被封装在某处的内容1、将内容封装到某处：class People: #定义⼀个People类def __init__(self,name,age,sex): #构造⽅法，（当实例化对象时，⾃动执⾏这个⽅法） = nameself.age = ageself.sex = sexP1 = People('allen','25','male') #实例化对象P1，将"allen"、25、"male"分别封装到了 P1/self 中的name，age，sex属性中P2 = People('yyh','18','male') #P2 ,同上# __init__ 中的self是⼀个形式参数，在实例化对象P1和P2的过程中，self分别等于P1和P2，相对于内容被分别封装到了P1和P2中，每个对象都有name、age、sex属性。
2、从某处调⽤被封装的内容：通过对象直接调⽤被封装的内容class People:def __init__(self,name,age,sex): = nameself.age = ageself.sex = sexP1 = People('allen','25','male')P2 = People('yyh','18','male')print #直接调⽤P1对象的name属性print #直接调⽤P2对象的name属性执⾏结果如下allenyyh通过self间接调⽤被封装的内容class People:def __init__(self,name,age,sex): = nameself.age = ageself.sex = sexdef getInfo(self):print print self.ageprint self.sexP1 = People('allen','25','male')P2 = People('yyh','18','male')P1.getInfo() #python默认会将P1传给self参数，即P1.getInfo(P1),此时P1=self,等于 是allen；self.age 是25； 是maleP2.getInfo(） #同上⼆、继承：继承，⾯向对象中的继承和现实⽣活中的继承相同，即：⼦可以继承⽗的内容。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
◆js的面向对象的三大特征
1.封装性
所谓封装，就是把我们抽象出的属性和对属性的操作写到类的定义中，称为封装.
js 中实现封装主要有两种封装( 公开，私有)
class Person(name,sal){
=name; //公开
var sal=sal;//私有
this.showInfo=function(){ //公开
window.alert(+””+sal);
}
showInfo2(){ //把函数私有化.
window.alert(“你好”++””+sal)
}
}
◆通过构造函数添加成员方法和通过原型法添加成员方法的区别
1.通过原型法分配的函数是所有对象共享的.
2.通过原型法分配的属性是独立.(如果你不修改属性，他们是共享)
3.建议，如果我们希望所有的对象使用同一一个函数，最好使用原型法添加函
数，这样比较节省内存.
function Dog(){
this.shout=function(){
}
}
//原型法
Dog.prototype.shout=function (){
window.alert("小狗尖叫"+);
}
//通过原型也可以给每个对象，分配属性
Dog.prototype.color="red";
var dog1=new Dog("aa");
var dog2=new Dog("bb");
if(dog1.shout==dog2.shout){
window.alert("dog1.shout==dog2.shout");
}
dog1.color="黑色";
window.alert(dog1.color+" "+dog2.color);
4.请大家看一个题:
function Person(){
}
// 创建对象
var p1=new Person();
// p1.say(); [错误]
// 这时用原型法分配
Person.prototype.say=function(){
window.alert("ok");
}
p1.say();
结论是类.prototype.函数=function (){};
称为后置绑定.
js面相对象的继承
看一段代码->问题是什么?
①对象冒充
代码如下:
<html>
<head>
<meta http-equiv="content-type" content="text/html;charset=utf-8"/>
<script type="text/javascript">
//中学生
/* function MidStu(name,age){
=name;
this.age=age;
this.show=function(){
window.alert(+"年龄是="+this.age);
}
this.pay=function(fee){
window.alert("你的学费是"+fee*0.8);
}
}
//小学生
function Pupil(name,age){
=name;
this.age=age;
this.show=function(){
window.alert(+"年龄是="+this.age);
}
this.pay=function(fee){
window.alert("你的学费是"+fee*0.5);
}
}*/
//代码的复用性不高.
//修改如下:
//1. 把子类中共有的属性和方法抽取出，定义一个父类Stu function Stu(name,age){
=name;
this.age=age;
this.show=function(){
window.alert(+"年龄是="+this.age);
}
}
//2.通过对象冒充来继承父类的属性的方法
function MidStu(name,age){
this.stu=Stu; //这里相当于把Stu构造函数(类)赋值给我们的属性this.stu
//调用this.stu方法
this.stu(name,age); //这个表示初始化MidStu,相当于执行Stu(name,age),这句话必须有，否则无法实现集成的效果
//可以写MidStu自己的方法.
this.pay=function(fee){
window.alert("你的学费是"+fee*0.8);
}
}
function Pupil(name,age){
this.stu=Stu;//这里只是把码继承.
//初始化一把
this.stu(name,age);
//可以写Pupil自己的方法.
this.pay=function(fee){
window.alert("你的学费是"+fee*0.5);
}
}
//测试
var midstu=new MidStu("贾宝玉",15);
var pupil=new Pupil("贾环",12);
midstu.show();
midstu.pay(100);
pupil.show();
pupil.pay(100);
</script>
</html>
②通过call 或者apply来实现
<html>
<head>
<meta http-equiv="content-type" content="text/html;charset=utf-8"/> <script type="text/javascript">
//中学生
/* function MidStu(name,age){
=name;
this.age=age;
this.show=function(){
window.alert(+"年龄是="+this.age);
}
this.pay=function(fee){
window.alert("你的学费是"+fee*0.8);
}
}
//小学生
function Pupil(name,age){
=name;
this.age=age;
this.show=function(){
window.alert(+"年龄是="+this.age);
}
this.pay=function(fee){
window.alert("你的学费是"+fee*0.5);
}
}*/
//代码的复用性不高.
//修改如下:
//1. 把子类中共有的属性和方法抽取出，定义一个父类Stu function Stu(name,age){
window.alert("确实被调用.");
=name;
this.age=age;
this.show=function(){
window.alert(+"年龄是="+this.age);
}
}
//2.通过对象冒充来继承父类的属性的方法
function MidStu(name,age){
//这里这样理解: 通过call修改了Stu构造函数的this指向,
//让它指向了调用者本身.
Stu.call(this,name,age);
//如果用apply实现，则可以
//Stu.apply(this,[name,age]); //说明传入的参数是数组方式
//可以写MidStu自己的方法.
this.pay=function(fee){
window.alert("你的学费是"+fee*0.8);
}
}
function Pupil(name,age){
Stu.call(this,name,age);//当我们创建Pupil对象实例,Stu的构造函数会被执行,当执行后，我们Pupil对象就获取从Stu封装的属性和方法
//可以写Pupil自己的方法.
this.pay=function(fee){
window.alert("你的学费是"+fee*0.5);
}
}
//测试
var midstu=new MidStu("孙悟空",15);
var pupil=new Pupil("猪八戒",12);
midstu.show();
midstu.pay(100);
pupil.show();
pupil.pay(100);
</script>
</html>
js的继承小结
(1)js对象可以通过对象冒充，实现多重继承Object 类是所有js类的基类。