JavaScript封装 继承 多态0711

JavaScript封装 继承 多态

1.封装(和java,c++一样)

1.1 首先了解一下什么是对象的私有变量和函数
  • 默认情况下对象中的属性和方法都是公有的, 只要拿到对象就能操作对象的属性和方法,外界不能直接访问的变量和函数就是私有变量和是有函数,构造函数的本质也是一个函数, 所以也会开启一个新的作用域, 所以在构造函数中定义的变量和函数就是私有函数
1.2 什么是封装
  • 封装性就是隐藏实现细节，仅对外公开接口
1.3 为什么要封装
  • 不封装的缺点：当一个类把自己的成员变量暴露给外部的时候,那么该类就失去对属性的管理权，别人可以任意的修改你的属性
  • 封装就是将数据隐藏起来,只能用此类的方法才可以读取或者设置数据,不可被外部任意修改. 封装是面向对象设计本质(将变化隔离)。这样降低了数据被误用的可能 (提高安全性和灵活性)
1.4 代码说明
  • function Person() {
    this.name = "lnj";
    // this.age = 34;
    let age = 34;
    this.setAge = function (myAge) {  //封装
        if(myAge >= 0){
            age = myAge;
        }
    }
    this.getAge = function () { //封装
        return age;
    }
    this.say = function () {
        console.log("hello world");
    }
}
let obj = new Person();
// 结论: 默认情况下对象的属性和方法都是公开的, 只要拿到对象就可以操作对象的属性和方法
// console.log(obj.name);
// obj.age = -3;
// console.log(obj.age);
// obj.say();
// console.log(age);
//封装后就不可任意修改
obj.setAge(-3);
console.log(obj.getAge());
1.5 私有属性注意点

  • 针对以上代码,我们看如下操作的区别

  • let obj = new Person();
// 1.操作的是私有属性(局部变量)
obj.setAge(-3);
console.log(obj.getAge());
/*
// 注意点:
// 在给一个对象不存在的属性设置值的时候, 不会去原型对象中查找, 如果当前对象没有就会给当前对象新增一个不存在的属性
// 由于私有属性的本质就是一个局部变量, 并不是真正的属性, 所以如果通过 对象.xxx的方式是找不到私有属性的, 所以会给当前对象新增一个不存在的属性
 */
 // 2.操作的是公有属性
 obj.age = -3;
 console.log(obj.age);  //因此会返回-3 ,而不是34
1.6 JavaScript 属性方法分类

  • 静态属性/静态方法

    • 通过构造函数访问的属性, 我们就称之为静态属性

    • 通过构造函数调用的方法, 我们就称之为静态方法

    • function Person() {
     this.name = "lnj";
     this.say = function () {
         console.log("hello world");
     }
}
 // 构造函数也是一个"对象", 所以我们也可以给构造函数动态添加属性和方法
 Person.num = 666;
 Person.run = function () {
     console.log("run");
 }
 console.log(Person.num);
 Person.run();

  • 实例属性/实例方法

    • 通过实例对象访问的属性, 我们就称之为实例属性
    • 通过实例对象调用的方法, 我们就称之为实例方法

2.继承

继承方式一 : 借用原型链实现继承

  • 直接将子类的原型对象修改为父类对象, 这样就能使用原型链上的属性和方法

  •  function Person() {
     this.name = null;
     this.age = 0;
     this.say = function () {
         console.log(this.name, this.age);
     }
 }
// 由于是直接将子类原型对象修改为了父类对象
// 所以继承的属性值很难自定义,当父类的值需要传进去时,子类对象不能满足这个功能
 function Student() {
     
     this.score = 0;
     this.study = function () {
         console.log("day day up");
     }
 }
 Student.prototype = new Person();
 Student.prototype.constructor = Student;
 var stu1 = new Student(99);
 console.log(stu.name, stu.age, stu.gender, stu.score);
继承方式二 : 借用构造函数实现继承

  • 在子类中调用父类构造函数, 并且将父类构造函数的this修改为子类对象

  •  // 父类
function Person(name, age, gender) {
    this.name = name;
    this.age = age;
    this.gender = gender;
}
// 借用构造函数只是调用了父类的构造函数, 借用了构造函数中的代码
// 相当于动态的给子类添加了许多属性, 但是并没有修改子类的原型
// 所以子类无法继承父类定义在prototype的方法和属性
Person.prototype.say = function () {
    console.log(this.name, this.age, this.gender);
}
// 子类
function Student(score, name, age, gender) {
    Person.call(this, name, age, gender);
    this.score = score;
}

var stu1 = new Student(99, "lnj", 33, "male");
var stu2 = new Student(66, "zq", 18, "female");
console.log(stu1.name, stu1.age, stu1.gender, stu1.score);
console.log(stu2.name, stu2.age, stu2.gender, stu2.score);
stu1.say(); // 报错
stu2.say(); // 报错
继承方式三 : 借用构造函数+借用原型链组合继承

  • 通过借用构造函数实现属性继承

  • 通过借用原型链实现方法继承

  • // 父类
function Person(name, age, gender) {
    this.name = name;
    this.age = age;
    this.gender = gender;
}
Person.prototype.say = function () {
    console.log(this.name, this.age, this.gender);
}
// 子类
function Student(score, name, age, gender) {
    Person.call(this, name, age, gender);
    this.score = score;
}
Student.prototype = Person.prototype;
Student.prototype.constructor = Student;
// 由于子类的原型指向了父类的原型, 所以操作的都是同一个原型对象
// 给子类的原型新增方法或者属性, 父类也会受到影响
Student.prototype.study = function () {
    console.log("好好学习天天向上");
};
Student.prototype.type = "学生";

var stu = new Student(99, "lnj", 33, "male");
stu.say();
stu.study();
console.log(stu.type);

var p = new Person("zq", 18, "female");
p.say();
p.study();
console.log(p.type);
继承方式四 : 专业写法
  •  // 父类
function Person(name, age, gender) {
    this.name = name;
    this.age = age;
    this.gender = gender;
}
Person.prototype.say = function () {
    console.log(this.name, this.age, this.gender);
}
// 子类
function Student(score, name, age, gender) {
    Person.call(this, name, age, gender);
    this.score = score;
}
Student.prototype = new Person();  //区别就在这
Student.prototype.constructor = Student;
// 由于子类的原型指向一个全新的对象
// 所以给子类的原型新增方法或者属性, 父类不会受到影响
Student.prototype.study = function () {
    console.log("好好学习天天向上");
};
Student.prototype.type = "学生";

var stu = new Student(99, "lnj", 33, "male");
stu.say();
stu.study();
console.log(stu.type);

var p = new Person("zq", 18, "female");
p.say();
p.study(); // 报错
console.log(p.type); // 报错

3.多态

  • 3.1 什么是强类型语言:
    一般编译型语言都是强类型语言,
    强类型语言，要求变量的使用要严格符合定义
    例如定义 int num; 那么num中将来就只能够存储整型数据
  • 3.2 什么是弱类型语言:
    一般解释型语言都是弱类型语言,
    弱类型语言, 不会要求变量的使用要严格符合定义
    例如定义 let num; num中既可以存储整型, 也可以存储布尔类型等
  • 3.3 由于js语言是弱类型的语言, 所以我们==不用关注多态==
  • 3.4 多态在编程语言中的体现
    父类型变量保存子类型对象, 父类型变量当前保存的对象不同, 产生的结果也不同
最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。

推荐阅读更多精彩内容

  • js中的继承问题
    学过java或者c#之类语言的同学,应该会对js的继承感到很困惑--不要问我怎么知道的,js的继承主要是基于原型(...
    木丿灬易阅读 258评论 0赞 1
  • pySpark 中文API (2)
    pyspark.sql模块 模块上下文 Spark SQL和DataFrames的重要类： pyspark.sql...
    mpro阅读 9,504评论 0赞 13
  • JavaScript自学笔记--基础部分2
    1、原型、原型链 1.1 原型的定义：原型是function对象的一个属性，原型定义了构造函数制造出的对...
    MrLsss阅读 266评论 0赞 1
  • 69-继承方式三
    将Student构造函数的原型对象改为Person构造函数的原型对象注意点: 要想使用Person原型对象中的属性...
    仰望_IT阅读 224评论 0赞 1
  • JavaScript Foundation
    JavaScript之父：Brendan Eich 。 -基本语法：借鉴了C语言和Java语言。-数据结构：借鉴了...
    饥人谷_kule阅读 611评论 0赞 0