面向对象：一切皆对象，程序中所有的操作都需要通过对象来完成。
在程序中，所有对象都被分成了两个部分数据和功能，以人为例，人的姓名、性别、年龄、身高等属于数据，人可以说话、走路、吃饭、睡觉这些属于人的功能。数据在对象中被称为属性，而功能就被称为方法。
1、类的基本使用(定义一个类）
- 类中可以定义属性和方法
- readonly关键字定义只读属性，不可以修改
- 使用static关键字定义类属性（静态属性），通过类直接获取
- 使用static关键字定义类方法（静态方法），通过类直接调用
class Person{
// 定义属性
name:string = 'Tom'
age:number = 18
// readonly关键字定义只读属性，不可以修改
readonly school:string = '小学'
// 使用static关键字定义类属性（静态属性），通过类直接获取
static region:string = '中国'
// 定义方法
sayHello(){
console.log('哈哈哈')
}
// 使用static关键字定义类方法（静态方法），通过类直接调用
static eat(){
console.log('吃东西')
}
}
let person = new Person()
console.log(person.name)
console.log(Person.region)
Person.eat()
2、构造函数和this
- 构造函数会在创建时被调用
- this表示新创建的实例对象
class Dog{
name:string
age:number
// 构造函数会在创建时被调用
constructor(name:string,age:number){
// this表示新创建的实例对象
this.name = name
this.age = age
}
sayName(){
console.log(this.name)
}
}
let dog = new Dog('小花',4)
console.log(dog.name)
3、类的继承和super关键字
继承：
- 使用extends关键字实现继承，使用继承后，子类将会拥有父类的所有属性和方法
- 子类方法可以覆盖父类方法，称为方法的重写 super关键字
- 在类的方法中，super就表示当前类的父类
- 如果在子类中写了构造函数，子类构造函数中必须对父类构造函数进行调用（没有写默认自动调用）
class Anamial{
name:string
age:number
constructor(name:string,age:number){
this.name = name
this.age = age
}
sayHello(){
console.log('动物在叫')
}
}
/*
使用继承后，子类将会拥有父类的所有属性和方法
通过继承可以将多个类中共有的代码写在一个父类中
*/
class Dog extends Anamial{
pingzhong:string
// 添加新的属性，要使用super关键字
// 如果在子类中写了构造函数，子类构造函数中必须对父类构造函数进行调用
constructor(name:string,age:number,pingzhong:string){
// super表示当前类的父类
super(name,age)
this.pingzhong = pingzhong
}
// 子类方法可以覆盖父类方法，称为方法的重写
sayHello(){
// super.sayHello() 可以直接调用父类中的方法
console.log('狗是汪汪叫')
}
// 可以写子类自己的方法
run(){
console.log(`${this.name}在跑~~~`)
}
}
let dog = new Dog('大黄',2,'柴犬')
console.log(dog.name) // 大黄
dog.sayHello() // 狗是汪汪叫
dog.run() // 大黄在跑~~~
4、抽象类和抽象方法
抽象类
- 以abstract关键字开头的类就是抽象类
- 抽象类不能用来创建实例对象
- 抽象类是专门用来继承的类 抽象方法
- 抽象方法使用abstract开头，没有方法体
- 抽象方法只能定义在抽象类中，子类必须对抽象方法进行重写
abstract class Animal{
name:string
age:number
constructor(name:string,age:number){
this.name = name
this.age = age
}
// 抽象方法使用abstract开头，没有方法体
// 抽象方法只能定义在抽象类中，子类必须对抽象方法进行重写
abstract sayHello():void
}
class Cat extends Animal{
// 子类必须对抽象方法进行重写
sayHello(){
console.log('喵喵喵')
}
}
let cat = new Cat('可乐',1)
cat.sayHello()
5、接口
接口定义了类的规范,可以在定义类的时候去限制类的结构，用来定义一个类中应该包含哪些属性和方法
- 接口可以当成类型声明来使用
- 接口可以重复定义，使用时为合并效果
interface myInterface{
name:string,
age:number
}
interface myInterface{
gender:boolean
}
type mytype = {
name:string,
age:number,
gender:boolean
}
// type和interface都可以当成类型声明来使用
const obj2:myInterface={
name:'hhh',
age:18,
gender:true
}
const obj3:mytype={
name:'hhh',
age:18,
gender:true
}
- 接口只定义对象的结构，而不考虑实际值，所有属性都不能有实际的值
- 在接口中所有的方法都是抽象方法
- 定义类时，可以使类去实现一个接口，实现接口就是使类满足接口的要求
// 定义接口
interface myInter{
name:string
sayHello():void
}
// 实现接口
class myClass implements myInter{
name: string
constructor(name:string){
this.name = name
}
sayHello(): void {
console.log('哈哈哈')
}
}
6、属性的封装（get和set）
类中属性可以任意的被修改,将导致对象中的数据变得非常不安全
TS可以在属性前添加属性的修饰符
- public:修饰的属性可以在任意位置访问（修改）数据
- protected:受保护的属性，只能在当前类和当前类的子类中被访问和修改
- private:私有属性,只能在类内部进行访问或修改
// 属性可以任意的被修改,将导致对象中的数据变得非常不安全
class Person{
// TS可以在属性前添加属性的修饰符
/*
public:修饰的属性可以在任意位置访问（修改）数据
protected:受保护的属性，只能在当前类和当前类的子类中被访问和修改
private:私有属性,只能在类内部进行访问或修改
- 通过在类中添加方法使得私有属性可以被外部访问
*/
private name:string
private age:number
constructor(name:string,age:number){
this.name = name
this.age = age
}
// 定义方法，用来获取name属性
getName(){
return this.name
}
// 定义方法，用来设置name属性
// 如果不想让外部改变name属性，可以去除setName方法
setName(name:string){
this.name = name
}
getAge(){
return this.age
}
// set方法可以对赋值进行限制
setAge(value:number){
// 判断年龄是否合法
if(value>0){
this.age = value
}
}
}
const person = new Person('Tom',18)
console.log(person.getName()) // Tom
person.setName('Mary')
console.log(person.getName()) // Mary
person.setAge(-20)
console.log(person.getAge()) // 还是18
TS中set和get的写法(简写)
class Person{
private _name:string
private _age:number
constructor(name:string,age:number){
this._name = name
this._age = age
}
get name() {
return this._name
}
set name(value) {
this._name = value;
}
}
const p1 = new Person('孙悟空',100)
p1.name='猪八戒'
console.log(p1.name) // 猪八戒
constructor简写方法:不用在写this
class Person{
constructor(public name:string,public age:number){
}
}
const p2 = new Person('小敏',20)
7、泛型
在定义函数或者类时，如果遇到类型不明确就可以使用泛型
// 不知道函数返回的是什么类型，传入的参数是什么类型，用泛型
// 不知道函数返回的是什么类型，传入的参数是什么类型，用泛型
function fn3<T>(a:T){
return a
}
let result = fn3(10) // 不指定泛型，TS可以自动对类型进行推断
let result1 = fn3<string>('hello') // 指定类型
// 多个泛型
function fn4<T,K>(a:T,b:K):T{
return a
}
fn4<string,number>('hello',12)
// 接口
interface myInter1{
length:number
}
// T extends Inter 表示泛型T必须是Inter的实现类
function fn5<T extends myInter1>(a:T):number{
return a.length
}
fn5('123')
// 类中泛型的使用
class Myclass<T>{
name:T
constructor(name:T){
this.name = name
}
}
const myclass1 = new Myclass('Tom')
const myclass2 = new Myclass(20)
