假期第八篇，对于基础的知识点，我感觉自己还是很薄弱的。
趁着假期，再去复习一遍

面向对象：程序中所有的操作都需要通过对象来完成

计算机程序的本质就是对现实事物的抽象，抽象的反义词是具体。比如照片是对一个具体的人的抽象，汽车模型是对具体汽车的抽象等。

在程序中所有的对象被分成两个部分，数据和功能。以人为例，人的姓名，性别，年龄，身高，体重等属于数据，人可以走路，说话，吃饭，睡觉这些属于人的功能，数据在对象中被称为属性，而功能称之为方法

1、接口

接口与类型声明很相似，类型声明使用type关键字定义，接口（Interface）使用Interface关键字定义

类型声明可以描述一个对象的类型，对对象进行限制，可以用来定义基本类型、联合类型、交叉类型、元组类型等

type myType = {name: string,age:number
}const obj: myType = {name: '莲花',age:38
}

类型声明，相同的名只能声明一次

接口同样可以描述一个对象的类型，对对象进行限制

接口也可以当作类型声明去使用，接口也是用来定义一个类结构，用来定义一个类中应包含哪些属性和方法，多了少了都会波浪线提示

interface myInterface {name: string,age:number
}const obj: myInterface = {name: '莲花',age:38
}

但是接口可以重复声明

接口主要用于描述对象的结构和类型，因此更适用于被实现或继承的情况。
接口可以在定义类的时候去限制类的结构
接口中的所有属性都不能有实际的值
接口只定义对象的结构，而不考虑实际的值
在接口中所有方法都是抽象方法

interface Person {name: string;age: number;sayHello(): void;
}

接口支持一些类型声明不支持的特性，例如可选属性、只读属性、函数类型等。

interface Person {name: string;age?: number; // 可选属性readonly id: number; // 只读属性sayHello(): void; // 函数类型
}

类型声明不支持定义可选属性、只读属性等，但支持联合类型、交叉类型等高级类型的定义，比接口更加灵活。

type Person = {name: string;age: number;
} & {gender: 'male' | 'female'; // 交叉类型
} | {gender?: string; // 联合类型
};

类型声明主要用于定义类型别名和复杂类型

type Age = number;type Person = {name: string;age: Age;
};type Gender = 'male' | 'female';type PersonInfo = {name: string;age: Age;gender: Gender;
};

2、属性的封装

为什么需要属性的封装？当通过class定义类，通过实例对象可以随意修改属性，对于一些特定的属性，比如钱，比如年龄，都不应该被随意的修改，属性如果可以任意被修改，将导致对象中的数据变得非常不安全

class Person  {name: string;age: number;constructor(name: string, age: number){ this.name = name,this.age = age}}const person1 = new Person('莲花', 18)
person1.name = '楼楼'
person1.age = -38
console.log(person1, 'person1')

很显然年龄不应该是负数，但是因为对象属性可以任意修改，如果有需要用到年龄做计算的地方，一定是会出错的。
那如果不希望被随意修改，可以在属性前添加属性的修饰符

访问修饰符包括三种：

public：公共的，可以在类的内部和外部访问，默认值为 public。
private：私有的，只能在类的内部访问（修改）。
protected：受保护的，只能在类的内部和派生类中访问。

class Person {private name: string;protected age: number;public gender: string;constructor(name: string, age: number, gender: string) {this.name = name;this.age = age;this.gender = gender;}public sayHello() {console.log(`Hello, my name is ${this.name}, I'm ${this.age} years old.`);}
}class Student extends Person {public grade: number;constructor(name: string, age: number, gender: string, grade: number) {super(name, age, gender);this.grade = grade;}public study() {console.log(`${this.name} is studying in grade ${this.grade}.`);}
}const person = new Person('Alice', 18, 'female');
console.log(person.name); // 编译错误，name 是 private 属性，只能在类的内部访问
console.log(person.age); // 编译错误，age 是 protected 属性，只能在类的内部和派生类中访问
console.log(person.gender); // 可以访问，gender 是 public 属性
person.sayHello(); // 可以访问，sayHello 是 public 方法const student = new Student('Bob', 16, 'male', 10);
console.log(student.name); // 编译错误，name 是 private 属性，只能在类的内部访问
console.log(student.age); // 编译错误，age 是 protected 属性，只能在类的内部和派生类中访问
console.log(student.gender); // 可以访问，gender 是 public 属性
student.sayHello(); // 可以访问，sayHello 是 public 方法
console.log(student.grade); // 可以访问，grade 是 public 属性
student.study(); // 可以访问，study 是 public 方法

如果想获取Person 中定义为私有属性的name，可以通过定义方法，向外暴露属性和修改属性，虽然同样可以修改，但是属性的访问权是内部定的，暴露出来才可以访问，不暴露就是私有属性

class Person {private name: string;protected age: number;public gender: string;constructor(name: string, age: number, gender: string) {this.name = name;this.age = age;this.gender = gender;}public sayHello() {console.log(`Hello, my name is ${this.name}, I'm ${this.age} years old.`);}//定义方法，用来获取name属性getName() {return this.name}//定义方法，用来设置name属性，从外面传入valuesetName(value:string) { this.name = value}
}const person = new Person('Alice', 18, 'female');
person.getName(); // 可以访问,间接的拿到name属性
person.setName('张丫丫')

上面提到的年龄不可以设置负数，也就可以通过方法进行限制
getter方法用来读取属性，setter方法用来设置属性，它们被称为属性的存取器

      getAge() { return this.age}setAge(value: number) {//先判断年龄是否合法if (value >= 0) { return this.age = value}}

3、泛型

泛型是一种在编译时还不确定具体类型的变量或函数。使用泛型可以增加代码的灵活性和可重用性，使代码更加通用化

假如我们知道参数的类型，方法的返回值类型，可以这样写：

function fn(a: number): number { return a 
}
fn(1)

假如有些情况下，不知道参数和返回的具体类型是什么，类型可以写成any，确实可以，但是any实际上会关闭掉ts中的类型检查
参数是any，返回值是any，就有可能参数是字符串，返回值是数值

function fn(a: any): any{ return a 
}
fn(1)

所以在定义函数或类的时候，类型不明确就可以使用泛型
在方法名后面用尖括号，大写的T或者任意大写字母都可以


泛型T只有在函数执行的时候才知道具体是什么类型
两种方法调用：

function fn<T>(a: T): T { return a 
}// 方法一：直接调用,不知道泛型，TS也可以自动对类型进行推断
fn(1)
// 方法二：手动指定泛型，如果有很复杂的情况，类型推断无法推断的时候
fn<string>('1')

泛型可以指定多个

function fn2<T,K>(a: T,b:K): T { 
console.log(b);return a 
}fn2(10,'嘻嘻嘻')
或
fn2 <number,string>(10,'嘻嘻嘻')

如果想限制泛型的范围，定义一个接口，希望泛型是实现Inter接口的类

//T extends Inter 表示泛型必须是Inter的实现类（子类）

传参的时候要有length属性，传数字没有会提示类型’number’的参数不能赋值给类型’Inter’的参数，因为数字里没有length

传字符串或有length属性的对象就可以