首先介绍一下我们的两大编程思想

1.面向过程（POP）

面向过程就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步步实现，使用时在一个个调用函数就行了在javascript中。

2.面向对象（OPP）

面向对象就是把事务分解成一个个对象，然后由对象之间分工合作完成。面向对象是以对象功能来划分问题的，而不是步骤！

面向对象的优点：灵活、容易维护、更适合多人合作的大项目。

面向对象的特性:

1. 封装性：把重复复用的代码块封装起来。

2. 继承性：例如有对象father和对象son,对象son就是可以继承对象father的属性和方法。

3. 多态性：同一个对象在不同是时刻体现出不同的状态

面向对象——继承

继承：是使用已存在的类的定义，作为建立新类的基础技术，新类可以增加新的属性或新的方法，也可以用父类的功能，但不能选择性地继承。通过使用继承，能够非常方便地复用这些代码。

关于继承，请记住如下 3 点：

子类拥有父类对象中的所有属性和方法（包括私有属性和方法，但这些子类是无法访问的，只是拥有）；

子类可以拥有自己的属性和方法，即子类可以对父类进行扩展；

子类可以用自己的方式重新实现（Override，重写覆盖）父类的方法。

class类继承通过expentds

// 定义一个父类
class Person {
 //父类的属性
 name;
 age;
 //将我们声明的值赋给对应的属性
 constructor(name, age) {
   this.name = name;
   this.age = age;
 }
 say(name, age) {
   //结果必须return出去
   return `我是${this.name},今年${this.age}岁`
 }
}
let p1 = new Person('张三', 21); //将参数传给父类
// console.log(p1);
console.log(p1.say());


 //让子类去继承父类
class Studet extends Person {
 constructor(name,age) {
   super(name, age); //可以通过super去表示父类的name和age
 }
 say(name,age) {
   return `我是${this.name},今年${this.age}岁`
 }
}
const result = new Studet('小红',30);
console.log(result.say());

若继承父类的一些属性之后还想增添属性可以用super()方法继承父类的方法，随后继续增添我们需要加的属性,如果添加参数会覆盖父类的参数

  // 定义一个父类
  class Person {
    //父类的属性
    name;
    age;
    //将我们声明的值赋给对应的属性
    constructor(name, age) {
      this.name = name;
      this.age = age;
    }
    say(name, age) {
      //结果必须return出去
      return `我是${this.name},今年${this.age}岁`
    }
  }
  let p1 = new Person('张三', 21); //将参数传给父类
  // console.log(p1);
  console.log(p1.say());

  //让子类去继承父类
  class Studet extends Person {
    hobby; //子类继承完子父类的属性后自己新增的属性
    constructor(name, age, hobby) {
      super(name, age); //可以通过super去继承父类的name和age
      this.hobby = hobby;
    }
    say() {
      return `我是${this.name},今年${this.age}岁,我的${this.hobby}是编程`
    }
  }
  const result = new Studet('小红', 30, '爱好'); //这是参数要在传一个
  console.log(result.say());

图一（在constructor的this）：

图二（在say()方法的this）：

TypeScript的修饰符

访问修饰符

public：公开的，谁都能用（默认public）
private：私有的，仅类自己里头才能使用
protected：受保护的，仅仅类和类的子类能使用

public：所有定义成public的属性和方法都可以在任何地方进行访问。

class Animal {
    public age:number=10;
    public run() {
        console.log("这是一个跑的方法")
    }
}
class Dog extends Animal{
    
}
let dog:Dog=new Dog()
dog.run()    //继承过来的方法
dog.age=99;   //继承过来的属性
console.log(dog.age)

private：所有定义成private的属性和方法都只能在类定义内部进行访问。

class Animal {
    private age:number=10;
    private run() {
        console.log("这是一个跑的方法")
    }
}
class Dog extends Animal{
    
}
let dog:Dog=new Dog()
//dog.run()    //属性“run”为私有属性，只能在类“Animal”中访问
//dog.age=99;   //属性“age”为私有属性，只能在类“Animal”中访问

protected：多有定义成protected的属性和方法可以从类定义内部访问，也可以从子类中访问。

class Animal {
    protected run() {
        console.log("这是一个跑的方法")
    }
}
class Dog extends Animal{
    constructor(){
        super()
        super.run()
    }
}
let dog:Dog=new Dog()
// dog.run()    //属性“run”受保护，只能在类“Animal”及其子类中访问

js面向对象和访问TypeScript的修饰符