对象—封装、继承

对象2

面向对象的三大特征:1、封装 2、继承 3、多态

封装

  • 概念:实现隐藏细节的过程。
  • 好处:1、重用
  • 2、隐藏实现的细节(可设置访问权限/级别)
  • 不限于面向对象,无处不在

纯面向对象的访问级别:

  • public 级别最低,均可访问
  • protected 仅限父与子之间
  • package 作用域,命名空间
  • private 级别最高

JS都是public,都可访问;可模拟private;不需要protected、package

let Student=function(name,age){
    this.name=name;
    //  let age =age; 报错,age已定义; 局部变量
    this.show=function(){
        console.log(‘我是‘+this.name);
    }

}
let stu1=new Stu(‘学生‘,20);
stu1.show();

或
 let Student=function(name,age){
    this.name=name;
    let_age=age;
    //  let age =age; 报错,age已定义; 局部变量
    this.show=function(){
        console.log(`我是${this.name},今年¥{_age}岁);
    }

}
let stu1=new Stu(‘学生‘,20);
console.log(stu1_age);
stu1.show();

修改器 set, 访问器 get

let Student=function(name,age,sex){
    this.name=name;
    this.age=age;
    this.sex=sex;
    this.show=function(){
        console.log(`我是${this.name},今年${this.age}岁,性别${this.sex}`);
    }
}                                                 ‘name‘ 属性名,字符串
Object.defineProperty(Student.prototype,‘name‘,{   //objec.defineProperty固定写法,Student.prototype设置set/get的对象
    set:function(name){     // 最后单独设置了名字,进入这一句,输出改变后的名字和‘我是set方法‘
        console.log(‘我是set方法‘);
        this._name=name;        // _name 初始化,必须加下划线
    },      // 作为参数,用逗号
    get:function(){          // 不管最后有没有单独设置其他名字,因为有return,都要进入这一句,输出‘我是get方法‘
        console.log(‘我是get方法‘);     //可有可无
        return this._name;
    }
});
let stu1=new Student(‘vivi‘,22,‘女‘);
console.log(stu1.name);
stu1.name=‘json‘;
stu1.age=30;
stu1.sex=‘man‘;
stu1.show();

继承

  • 概念:一个类沿用了父类的属性、方法,并且可拥有自己的属性、方法的行为就是继承。
  • 好处:1、重用 2、扩展(自己的东西)
  • 缺陷:(零型?)继承

JS-单根继承,缺陷得到一定解决;es6以前JS没有继承方法

继承方法

1、对象冒充法

let People =function(name,age){
    this.name=name;
    this.age=age;
}
People.prototype.into=function(){   // 方法;可继承共有的;into自己取的名字
    console.log(`Hi,我是${this.name}`);
}
let ChinesePeople=function(name,age){
    this.inhert=People;
    this.inhert=(name,age);  // 不是继承,只是调用别人的
    delete this.inhert;      // delete 关键字
}
let c1=new ChinesePeople("姓名",22);
console.log(c1.name,c1.age);     // 输出 姓名,20
c1.intro(); // 检测,输出 空; (1)
console.log(c1.instanceof CinesePeople);  // instanceof 检测;输出true; (2)
console.log(c1.instanceof People); // 输出false;不是继承;(3)

call/apply区别:传参 call(参数列表) apply(数组)

同上

let ChinesePeople=function(name,age){
    People.call(this,name ,age);
    People.apply(this[name,age]);

}
let c1=new CinesePeople("姓名",22);

2、原型链

  • 把原来的原型改为另一对象,作为原型
  • 能变成真的继承
  • 缺陷:不能传值
同上
...
let c1=new ChinesePeople(‘姓名‘,22);
console.log(c1.__proto__);  // 访问原型;__proto__ 是2条下划线; ChinesePeople{}...
console.log(c1.__proto__.__proto__.__proto__); //一级一级往上访问原型 

3、混合方式

let ChinesePeople=function(name,age){
    People.call(this,name,age);   // 加入这句

}
ChinesePeople.prototype = new People();
let c1 = new ChinesePeople("姓名",20);
let c2 = new ChinesePeople("姓名",21);

console.log(c1.name,c1.age);
c1.intro();

console.log(c1 instanceof People);

prototype 和 proto 区别:

  • prototype:1、构造函数的方法属性 2、可改变原型
  • proto: 1、是每个函数的属性,通过对象依次往上找原型 2、不可改变原型,只能访问

总结

  • 面向对象:把复杂问题简单化,更接近人类思维
  • 对象本身是一种数据类型,包含很多属性的集合,方法也是属性
  • es5:要初始化必须加_下划线封装
  • 封装:运用 修改器set、访问器get , 必须写 Object.definePropertype;
  • 例:
    
     Object.definePropertype(Teacher.prototype,‘name‘{
        set:function(name){
           this.name=name;
        },   // 作为参数,使用逗号
        get:function(){
            return this._name;
        }
    
    });
  • 继承:1、对象冒充法不是继承,运用关键字delete,输出可用intro、intanceof检测
  • 2、原型链:能变成真的继承,运用proto ,可一级一级访问原型,检测;但是不能传值
  • 3、混合方式:加入 call 或 apply
时间: 2024-11-07 12:27:56

对象—封装、继承的相关文章

Javascript的对象封装和继承有哪些方法?优劣分别是什么?

1. 对象封装方法 1) 原始模式生成对象 直接将我们的成员写入对象中,用函数返回. 缺点:很难看出是一个模式出来的实例. function Stu(name, score) {             return {                 name: name,                 score: score             }         }         var stu1 = Stu("张三", 80);         var stu2 =

类与对象 面向对象和面向过程对比 面向对象三大特征:封装 继承 多态

 初识面向对象 面向过程: 一切以事务的发展流程为中心. 面向对象: 一切以对象为中心. 一切皆为对象. 具体的某一个事务就是对象 打比方: 大象进冰箱 步骤: 第一步, 开门, 第二步, 装大象, 第三步, 关门 面向对象:大象, 你进冰箱. 此时主语是大象. 我操纵的是大象. 此时的大象就是对象 1. 面向过程: 一切以事物的流程为核心. 核心是"过程"二字, 过程是指解决问题的步骤, 即, 先?干什么, 后干什么. 基于该思想编写程序就好比在编写一套流水线. 是一种机械 式的编程

封装继承多态到底讲的是什么

封装继承多态到底讲的是什么 封装.继承.多态并不是针对C#语言提出来的,他是一个在面向对象思想下产生的一个概念.所以想要弄明白封装.继承.多态,首先就要先了解面向对象概念. 封装:当我们提及面向对象的时候,这个对象怎么来?就是通过我们人为的封装得来.封装就是把一些特征或功能组合到一个抽象的对象上.就比如说电脑:它的特征是有一个显示屏,有一个主机,有鼠标和键盘等等.功能有计算等.那我们把这些特征和功能组合到“电脑”这个抽象的名词上时,“电脑”于是就有了这些特征和功能.但这个“电脑”不是实物,它代表

(1) 深入理解Java面向对象三大特性 封装 继承 多态

转眼已经工作快6年了,最开始做了2年J2EE:然后整了2年的数据仓库,主要是Cognos的报表开发:现在从事4G LTE核心网的开发,用的语言任然是Java,但写代码的机会不多,基本都是看代码找BUG,偶尔做点new feature也是在比较成熟的框架上复制.粘贴.修改,大部分时间还是在理解业务,钱多.事少.离家近,当时来这家公司图的是后面2点,2年过去了,英文水平有所提升,对敏捷开放也有一定的了解,但技术方面明显退步了或者说没有进步吧,本来以前也不怎么好,因为工作上用不到,自己也没怎么学习,所

JavaScript对象 创建对象 继承

创建对象  --以下内容来自JavaScript高级程序设计 工厂模式 用函数来封装以特定接口创建对象的细节. function createPerson(name, age, job){ var o = new Object(); o.name = name; o.age = age; o.job = job; o.sayName = function(){ alert(this.name); }; return o; } var person1 = createPerson("Nichola

Javascript对象的继承

对象的继承 Javascript主要通过原型链实现继承,原型链的构建是通过将一个类型的实例赋值给另一个构造函数的原型实现的. 由于所有的实例对象共享同一个prototype对象,那么从外界看起来,prototype对象就好像是实例对象的原型,而实例对象则好像"继承"了prototype对象一样.这就是Javascript继承机制的设计思想. 继承方法: (1)原型链继承方法:基本思想是利用原型让一个引用类型继承另一个引用类型的属性和方法.继承是通过创建超类型的实例,并将该实例赋给子类型

Javascript之对象的继承

继承是面向对象语言一个非常重要的部分.许多OOP语言都支持接口继承和实现继承两种方式.接口继承:继承方法签名:实现继承:继承实际的方法.在ECMAScript中函数是没有签名的,所以也就无法实现接口继承,只能支持实现继承. 在JavaScript中有大概六种继承方式,它们分别是:原型链继承,借用构造函数继承,组合继承,原型式继承,寄生式继承和寄生组合式继承.下面就是对着六种继承方式的详细介绍. 1.原型链 基本思想是利用原型让一个引用类型继承另一个引用类型的属性和方法.在这里还得补充一下,每个构

JavaScript大杂烩4 - 理解JavaScript对象的继承机制

面向对象之继承 JavaScript是单根的面向对象语言,它只有单一的根Object,所有的其他对象都是直接或者间接的从Object对象继承(没有指定父类的对象,都被认为是从Object继承的). 在前面我们讨论了面向对象的封装性,在最后的地方也谈到了JavaScript的继承是通过原型和原型链实现的,下面我们就详细的展开这个问题:JavaScript到底是如何实现继承的? 继承的本质 继承的本质是重用,从语法上来讲,继承就是"D是B"的描述,其中B是基类,描述共性,D是子类,描述特性

javascript中的对象之间继承关系

相信每个学习过其他语言的同学再去学习JavaScript时就会感觉到诸多的不适应,这真是一个颠覆我们以前的编程思想的一门语言,先不要说它的各种数据类型以及表达式的不同了,最让我们头疼,恐怕就是面向对象的部分了,在JavaScript中,是没有给定一个创建对象的关键词的,它不像Java中一个class就可以创建一个对象,在JavaScript中,对象是一个十分松散的的key-value对的组合,通常,我们在创建对象时,可以通过{}来直接生成一个对象,就像我们之前所学的,对象中有属性,有行为,这里我

面向对象三大特性:封装,继承,多态(二、多态)

多态 一,多态的概念 多态(polymorphism), 是指一个名字可以有多种语义.在面向对象语言中,多态是指在一棵继承树中的类中可以有多个同名但不同方法体及不同形参的方法.通常有两种途径实现多态:方法的重载和覆盖. 多态性允许以统一的风格处理已存在的变量及相关的类.多态性使得向系统里增加新功能变得容易.继承性和多态性是降低软件复杂性有有效技术. 二,多态的实现 1.方法的重载 方法重载时: 参数必须不同.参数个数不同或类型不同. 返回值可以相同,也可以不同. 重载的价值在于它允许通过使用一个