TS第3天 Tpeyscript面向对象

面向对象 OOP

一切皆对象

config.json中配置

{
    "compilerOptions": {
        "module":"es2015",
        "target": "ES2015"
    }
}

命令

tsc -w    //全局监听并自动编译

02.ts 文件

类

static 关键字用于定义类的数据成员（属性和方法）为静态的，静态成员可以直接通过类名调用。

static readonly
static ：静态方法，只能类访问or 调用
readonly ：只读，只能访问属性，不能修改属性

class person{          //person  类
    name:string="df"
    readonly age:number= 18   //只读不能修改
    static sex:string = "男"   //静态属性 只能类访问，实例不能访问
    
    say() {
        console.log('hi');
    }
}

const p = new person()    //p 实例
console.log(p.name,)
console.log(person)
console.log(p.sex);  报错  //static静态属性不能用实例访问和编辑，只能类访问
person.sex ="女"   
console.log(person.sex);
person.age = 20   //报错，readonly 只读  不能修改
 
 p.say();   //同理  static  只能类调用

构造函数 和 this

this： 在类中，使用this表示当前对象

class Dog{
    name:string
    age:number

    //构造函数会在对象创建时调用
    constructor(name:string,age:number){
      //在实例方法中，this就是当前的实例  
      //在构造函数中，当前对象就是当前新建的那个对象
      //可以通过this向新建的对象中添加属性
        this.name = name;
        this.age =age;
    }

    bark(){
        //在方法中this表示当前调用方法的实例对象
        console.log(this)
    }
}
const dog1 = new Dog('小黑',4)
const dog2 = new Dog('小白',5)

console.log(dog1.bark())//Dog {name: '小黑', age: 4}
console.log(dog2.bark());//Dog {name: '小小', age: 5}

dog1调用 this 就执行dog1 ，dog2调用 this 就执行dog2

extends 继承

子类可以对父类的方法重新定义，这个过程称之为方法的重写。

class Animal{
    name:String
    age:number
    constructor(name:string,age:number){
        this.name = name;
        this.age =age
    }
    say(){
        console.log('动物在叫~~~');
    }
}

//使用继承后，子类将拥有父类所有的 方法和属性
//通过继承可以将多个类中共有的代码写在一个父类中
//可以在子类中添加父类没有的 属性和方法

class Dog1 extends Animal{
  return (){
    console.log(`${this.name}在跑~~~`)
  }
}
class Cat extends Animal{
   say(): void {
     console.log('我是小猫~~~');   //重写了父类的方法
   }
}

const dog = new Dog1("小狗",3)
const cat = new Cat("小猫",2)
console.log(dog);  //Dog1 {name: '小狗', age: 3}
console.log(cat);  //Cat {name: '小猫', age: 2}
console.log(dog.say())   //动物在叫~~~
console.log(cat.say())   //我是小猫~~~

super

super 关键字是对父类的直接引用，该关键字可以引用父类的属性和方法。

class Animal2{
    name:string
    constructor(name){
        this.name = name;
    }
    say(){
        console.log('动物在叫~~~')
    }
}

class Dog2 extends Animal2{
    age:number
    //在子类中写了构造函数，这时候必须在子类构造函数中用super调用一下父类的（理解成会把父类的覆盖）
   constructor(name:string,age:number){
    super(name)
    this.age = age
   }

}

const dog3 = new Dog2("小狗",3)
console.log(dog3.age)   //3
console.log(dog3.name)   //小狗

abstact

• 抽象类，只能被其他类所继承不能用来创建实例，抽象类就是专门用来被继承的
• 抽象方法：在抽象类中，没有方法体，子类继承抽象类时抽象方法必须要实现，（换句话说就是规定子类必须重写或者说有的方法）

// 抽象类，不能用来创建对象，抽象类就是专门用来被继承的
abstract class Animal3 {
    name:string
    constructor(name) {
        this.name = name;
    }
    abstract  say() :void;   //抽象方法只能在抽象类里，抽象方法没有方法体，子类必须重写
        
    
}
class Dog3 extends Animal3 {

     age:number
    constructor(name, age) {
        super(name);
        this.age = age;
    }
    say() {
     console.log('dddd')    //子类必须有父类的say()方法 ,不然就报错
    }
}
const dog4 = new Dog3("小狗", 3);
console.log(dog4.age);
console.log(dog4.name);

interface

• interface 定义接口，就相当于规定了一个类的结构
• implements 实现接口

//接口只定义对象的结构，不考虑实际值
//在接口中所有的方法都是抽象方法。(抽象方法就是必须在子类中重写)

interface myInter{
    name:string
    say():void;
}

class myClass implements myInter{
    name: string;
    constructor(name){
        this.name = name
    }
    say() {   //如果不定义该方法会报错，因为接口中有定义
        console.log(this.name)
    }
}

const myclass = new myClass('xiaod');
myclass.say()   // xiaod

属性封装

static：静态属性 明为static的属性或方法不再属于实例，而是属于类的属性；
readonly ：只读属性，如果在声明属性时添加一个readonly，则属性便成了只读属性无法修改，
修饰符：
public（默认值），可以在类、子类和对象中修改
protected ，可以在类、子类中修改
private ，可以在类中修改

constructor 语法糖

class M{
    constructor(public name:string,public age:number){
    }
    say(){
        console.log('dddd');
    }
}

等价于

class M{
    public name:string
    public age:number
    constructor(name:string,age:number){
        this.name = name 
        this.age =age
    }
}

public

class M {
    constructor(name, age) {
        this.name = name;
        this.age = age;
    }
    say() {
        console.log('dddd');
    }
}
class N extends M {
    constructor(name, age) {
        super(name, age);
        this.name = name; //可以在子类中修改
    }
}
const n = new N('cc', 11);
n.name = "bb"; //可以在对象中修改
console.log(n.name);

protected

class M{
    constructor(protected name:string,protected age:number){

    }
    say(){
        console.log('dddd');
    }
}
class N extends M{
   constructor(name:string,age:number){
    super(name,age);
    this.name =name  //可以在子类中修改
   }
}
const n = new N('cc',11)
n.name="bb"  // 这里报错，不可以通过对象修改

provide

class M{
    constructor(private name:string,private age:number){

    }
    say(){
        console.log('dddd');
    }
}
class N extends M{
   constructor(name:string,age:number){
    super(name,age);
    this.name =name  //报错，不可以在子类中修改
   }
}
const n = new N('cc',11)
n.name="bb"  // 这里报错，不可以通过对象修改

属性存取器

• 对于一些不希望被任意修改的属性，可以将其设置为private 直接将其
• 设置为private将导致无法再通过对象修改其中的属性
• 我们可以在类中定义一组读取、设置属性的方法，这种对属性读取或设置的属性被称为属性的存取器
• 读取属性的方法叫做setter方法，设置属性的方法叫做getter方法

class Person{
    private _name: string;

    constructor(name: string){
        this._name = name;
    }

    get name(){
        return this._name;
    }

    set name(name: string){
        this._name = name;
    }

}

const p1 = new Person('孙悟空');
// 实际通过调用getter方法读取name属性
console.log(p1.name);
// 实际通过调用setter方法修改name属性 
p1.name = '猪八戒';