Day13-面向对象编程

Day13-面向对象编程

一 回顾

变量,数组,对象都是容器,都可以用来存储数据

let n = 10
let arr = [3,5,7]
let stu = {name:"张恒",age:18,sex:"女"}

二 面向对象思想

面向过程：将开发的步骤按照顺序一步一步往下执行，直到程序结束

面向对象：将项目中要涉及到对象抽取出来，每个对象负责自己那一部分数据,对象之间相互调用完成业务

类:一系列具有相同特性的对象的统称
对象:某一个具体的事务
	对象的属性:特征(姓名,性别,年龄)
	对象的方法:对象的行为(吃饭,跑步)

三 对象的创建

先造模具:模具就是类

/**
 * 类
 */
class Student{
    name
    sex
    age
}

然后把类作为模具来创建对象容器

/**
 * 类(表头或模版)
 */
class Student{
    name
    sex
    age
}

//使用类创建对象
let stu1 = new Student()
//给对象的属性赋值
stu1.name = "赵日天"
stu1.sex = "男"
stu1.age = 20
console.log(stu1);

let stu2 = new Student()
stu2.name = "李杀神"
stu2.sex = "男"
stu2.age = 21
console.log(stu2);

练习:创建对象把下面5件商品的信息存储起来,并打印输出

四 类和对象练习

类(Class) 由3个部分构成

• 类的名称:类名
• 类的属性:特征
• 类的方法:对象的行为

举例：

1）人类设计,只关心3样东西:

• 事物名称(类名):人(Person)
• 属性:姓名(name)、身高(height)、年龄(age)
• 方法(行为/功能):跑(run)、打架(fight)

class Person{
    name
    height
    age
    run(){
        console.log(this.name + "跑步");
    }
    fight(){
        console.log(this.name + "打架");
    }
}

//创建对象
let p1 = new Person()
//给对象的属性赋值
p1.name = "赵日天"
p1.height = 180
p1.age = 20
console.log(p1);
//调用对象的方法
p1.run()
p1.fight()

//创建对象
let p2 = new Person()
//给对象的属性赋值
p2.name = "王诛魔"
p2.height = 190
p2.age = 25
console.log(p2);
//调用对象的方法
p2.run()
p2.fight()

2）狗类的设计

• 类名:狗(Dog)
• 属性:名字、毛色、性别
• 方法(行为/功能):跑、吃、

五 构造器

/**
 * 构造器的特点
 *  1.类中没有写构造器默认由一个无参构造器 
 *  2.构造器是在创建对象的时候自动执行
 *  3.如果手动写了构造器,会覆盖掉默认的无参构造器
 *  4.一个类只能有一个构造器
 * 构造器的作用:
 *  实现对象属性的初始化
 */

class Person{
    name
    height
    age
    constructor(name,height,age){
        this.name = name
        this.height = height
        this.age = age
    }
}

let p1 = new Person("赵日天",180,20)
console.log(p1);

六 静态方法

class Person{
    /**
     * 静态方法
     * 静态方法可以使用类名.方法调用
    */
    static eat(){
        console.log("--吃饭--");
    }
}


//调用静态方法
Person.eat()

静态方法是被static修饰的方法,可以直接通过 类.方法名访问

普通属性和方法只能通过对象访问

七 继承

面向对象编程的三大特征

​ 封装

​ 继承

​ 多态

1.继承简介

2.继承的好处

3.继承的语法

继承关键字：extends

案例

需求：开发动物类，以及狗类和猫类，如下：

/**
 * 父类
 */
class Animal{
    name
    age
    color
    //构造器
    constructor(name,age,color){
        this.name = name
        this.age = age
        this.color = color
    }
    eat(){
        console.log("吃饭");
    }
    run(){
        console.log("跑步");
    }
}

/**
 * 子类
 */
class Dog extends Animal{

    lookHome(){
        console.log("看家");
    }
}

class Cat extends Animal{
    sex
    catchMouse(){
        console.log("抓老鼠");
    }
}

let dog = new Dog()
dog.name = "大黄"
dog.age = 3
dog.color = "黄色"
console.log(dog);
dog.eat()
dog.run()
dog.lookHome()

console.log("------------");
let cat = new Cat()
cat.name = "小白"
cat.age = 2
cat.color = "白色"
cat.sex = "雌"
console.log(cat);
cat.eat()
cat.run()
cat.catchMouse()

//创建dog对象
let dog2 = new Dog("大灰",4,"灰色")
console.log(dog2);
dog2.run()
dog2.eat()
dog2.lookHome()

//创建猫对象
let cat2 = new Cat('小黄',2,"黄色")
cat2.sex = "雄"
console.log(cat2);
cat2.run()
cat2.eat()
cat2.catchMouse()

子类继承父类的属性和方法

八 重写

方法重写(子类把父类的方法重新写一遍,改变方法体)
	  	当父类的方法无法满足子类需求时,在子类中对父类的方法进行重写
	 	子类对象调用的是重写后的方法

/**
 * 父类
 */
class Animal{
    name
    age
    color
    //构造器
    constructor(name,age,color){
        this.name = name
        this.age = age
        this.color = color
    }
    eat(){
        console.log("吃饭");
    }
    run(){
        console.log("跑步");
    }
}

/**
 * 子类
 */
class Dog extends Animal{
    /**
     * 在子类中把父类的方法重新写一遍,改变方法体
     */
    eat(){
        console.log("狗喜欢吃骨头");
    }
    lookHome(){
        console.log("看家");
    }
}

class Cat extends Animal{
    sex
    /**
     * 在子类中把父类的方法重新写一遍,改变方法体
     */
    eat(){
        console.log("猫喜欢吃鱼");
    }
    catchMouse(){
        console.log("抓老鼠");
    }
}

思考如下功能实现

	定义员工类，具有姓名、年龄、性别属性，并具有工作的方法。定义管理层类，继承员工类，并有自己的职务和年薪属性，重写工作的方法。定义职员类，继承员工类，并有自己的属性所属部门和月薪,重写工作的方法；其中管理层的工作是下达指令,职员的工作是完成任务

/**
 * super
 *  写在子类中,用来访问父类的属性,方法以及构造方法
 *  如果想使用super访问父类的构造方法,super必须写在子类的构造方法的第一行
 */

class Staff{
    name
    age
    sex
    working(){
        console.log("工作");
    }
}

class Manager extends Staff{
    post
    yearSalary
    constructor(name,age,sex,post,yearSalary){
        super()
        this.name = name
        this.age = age
        this.sex = sex
        this.post = post
        this.yearSalary = yearSalary
    }
    working(){
        console.log("下达指令");
    }
}

class Employee extends Staff{
    dept
    monthSalary
    constructor(name,age,sex,dept,monthSalary){
        super()
        this.name = name
        this.age = age
        this.sex = sex
        this.dept = dept
        this.monthSalary = monthSalary
    }
    working(){
        console.log("完成任务");
    }
}

//创建管理层对象
let m1 = new Manager("赵日天",25,"男","项目经理",200000)
let m2 = new Manager("李杀神",26,"男","产品经理",210000)
let m3 = new Manager("王诛魔",27,"男","技术总监",300000)
console.log(m1);
m1.working()

//创建员工对象
let e1 = new Employee("刘斩仙",22,"男","前端开发部",8000)
console.log(e1);
e1.working()

九 super关键字的用法

	super写在子类中,用来访问父类的属性和方法
	super可以在子类的构造方法中调用父类的构造方法,而且必须写在子类构造方法的第一行

十 练习

给员工添加 申报税额和社保号属性
创建一个父类：company类（公司名字、包含地址、交税行为，查询社保号）
创建一个子类：成都分公司(属性一：education教育、属性二：emps:[],行为一：添加一个员工，行为二：删除一个员工，查看员工社保号)
创建一个子类：北京分公司(属性一：医疗、属性二：emps:[],行为一：添加一个员工，行为二：删除一个员工，查看员工社保号)
创建一个成都分公司，完成对员工增删查 （查所有员工，查询员工交税、社保）

/**
 * 父类
 */
class Company{
    companyName
    payTax(empName,money){
        let emp = this.emps.find(e => e.name == empName)
        emp.tax += money
    }
    queryNumber(empName){
        let emp = this.emps.find(e => e.name == empName)
        if(emp){
            console.log(emp.name+"社保号为"+emp.number);
        }else{
            console.log("没有该员工");
        }
    }
}
/**
 * 子类
 */
class CDcompany extends Company{
    type
    emps=[]
    add(obj){
        this.emps.push(obj)
    }
    delete(empName){
        let index = this.emps.findIndex(e =>e.name == empName)
        this.emps.splice(index,1)
    }
    queryAll(){
        this.emps.forEach(e =>{
            console.log(e);
        })
    }
    queryTax(empName){
        let emp = this.emps.find(e =>e.name == empName)
        console.log(emp.tax);
    }
}

//创建成都分公司对象
let cobj1 = new CDcompany()
cobj1.companyName = "蜗牛教育成都分公司"
cobj1.type = "教育"
//增
cobj1.add(m1)
cobj1.add(m2)
cobj1.add(m3)

//删除员工
cobj1.delete("赵日天")

//查询所有员工
cobj1.queryAll()

//查询员工的社保号
cobj1.queryNumber("赵日天")

//缴税
cobj1.payTax("李杀神",1000)
//查询缴税
cobj1.queryTax("李杀神")