Ts面向对象

2023-12-01 23:28:04

Ts面向对象

面向对象：把数据及对数据的操作方法放在一起，作为一个相互依存的整体——对象。对同类对象抽象出其共性，形成类。类中的大多数数据，只能用本类的方法进行处理。类通过一个简单的外部接口与外界发生关系，对象与对象之间通过消息进行通信。程序流程由用户在使用中决定。对象即为人对各种具体物体抽象后的一个概念，人们每天都要接触各种各样的对象，如手机就是一个对象。

class Person{
    name:string = '孙悟空';
    static age:number = 18
    readonly gender:string = '男'
    sayHello(){
        console.log("说你好！")
    }
    static  sayHello(){
        console.log("说你好！")
    }
}
const per = new Person
console.log(per.name)  //实例化对象进行访问
console.log(Person.age)//仅仅静态类型可以通过类进行访问
console.log(per.gender)//增加只读属性后只能对属性进行读取，而不能进行更改
per.sayHello();  //在使用方法时后使用实例和使用类是一样的
Person.sayHello();

构造函数和this

class Dog{
 constructor(name:string,age:number){
     console.log(this)
     this.name = name;
     this.age = age;
 }
    
}
let dog1 = new Dog();  //每一个实例中实例就是构造函数中的this，简而言之就是当前对象
//当new dog()时候相当于调用了构造函数，也就是实例是从类中延申出来的

继承

class Animal{
   constructor(name:string,age:number){
     console.log(this)
     this.name = name;
     this.age = age;
 }
    sayHello(){
        console.log("动物在叫！")
    }
}
class Dog extends Animal{   //实际上就是扩展继承过后animal所有的属性dog都包含
   run(){
       console.log("我在跑~")
   }
}
//如果想在子类中增加父类中没有的属性直接添加即可
//仅仅这样继承满足不了需求这样无论怎么调用sayHello方法都会输出动物在叫
class Dog extends Animal{   //实际上就是扩展继承过后animal所有的属性dog都包含
    sayHello(){
        console.log("喵喵喵") //在继承中对方法进行重写可以将父类的方法进行覆盖
    }
}

super关键字

//super相当于父类
//主要的运用场景是向子类中增加一些属性，如果在子类中写了构造函数，必须调用父类的构造函数
class Animal{
   constructor(name:string,age:number){
     console.log(this)
     this.name = name;
     this.age = age;
 }
    sayHello(){
        console.log("动物在叫！")
    }
}
class Dog extends Animal{   //实际上就是扩展继承过后animal所有的属性dog都包含
    constructor(name:string,age:number,gender:string){
     super(name,age)   
     console.log(this)
     this.name = name;
     this.age = age;
     this.gender = gender   
 }
   run(){
       console.log("我在跑~")
   }
}

抽象类

abstract  class Animal{    //以abstract开头的类为抽象类，只不过不能用来创建实例对象，（仅仅为了给别人当爸爸）
   constructor(name:string,age:number){
     console.log(this)
     this.name = name;
     this.age = age;
 }
    abstract sayHello():void  //抽象方法只能定义在抽象类中，在继承中会强制重写抽象方法
}

接口(Ts特有)

//接口迎来定义一个类的结构,用来定义类中应该包含哪些属性和方法
interface myInterface{
    name:string
    age:number
}
interface myInterface{
    gender:string
}
//接口重名是合法的调用时候相当于内容的相加
//接口可以在定义时候限制类的结构
//接口中所有的属性不能有实际的值
//接口只定义对象的结构而不考虑实际的值
//在接口中所有的方法都是抽象方法 
//定义类可以实现一个接口(就是类要满足接口的要求)
class Myclass implements myInterface{
     constructor(name:string,age:number){
     console.log(this)
     this.name = name;
     this.age = age;
 }    
}
//接口的意义在于
//接口就是一个规范,就是对类的限制，只要满足接口的要求就可以在特定的场景中使用
//接口和抽象类的区别在于，接口的实现仅仅只有抽象方法，而抽象类可以有抽象方法和普通方法

属性的封装

//如果没有对属性进行封装，属性可以任意被修改，所以需要对属性进行封装，可以在属性前添加属性修饰符
class Person{
   public   name:string = '孙悟空';
   pravite  age:number = 18
   getName(){
       return name
   }//用来获取
   setName(value:string){
     this.name = string  
   }//用来更改name
   get name(){
    return this._name
  }//可以写起来更加方便
   set name(value:string){
        this._name = value  
   }
}
let p = new Person()
p.getName() //获取类中的数据
p.setName("wwwwww") //将类中的name属性更改成wwww
//pubulic公共属性，不写默认是公共方式
//pravite私有属性，只能在类的内部进行修改，可以在类的内部定义方法在外边可以使用
//protected保护属性，只能在类里面或者当前类子类里面进行更改

新语法

class Dog extends Animal{   //实际上就是扩展继承过后animal所有的属性dog都包含
    constructor(pubulic name:string, pravite age:number,protected gender:string){
     super(name,age)   
     console.log(this)
     this.name = name;
     this.age = age;
     this.gender = gender   
 }

泛型（为了明确类型）

//类型不确定的类型
function fn<T,K>(a:T,b:K):T{
   return a 
}
//直接调用具有泛型的函数
fn(10);//可以自己判断
fn<number>("111111")//手动指令的将数据的类型设置为number
Interface inter{
    length:number
}
function fn<T extends inter>(a:T):number{
    return a.length
}
//在类中使用泛型
class Myclass<>{
    name:T,
    constructor(name:T){
       this.name = name 
    }
    
}
let ccc = new Myclass<string>("孙悟空")

接口和泛型，抽象类是锦上添花的作用。

码农公寓

Ts面向对象

构造函数和this

相关文章